fix: Move more directories

cloud/packages/core/src/utils/fn.ts

@@ -0,0 +1,27 @@
+import { ZodSchema, z } from "zod";
+
+export function fn<
+    Arg1 extends ZodSchema,
+    Callback extends (arg1: z.output<Arg1>) => any,
+>(arg1: Arg1, cb: Callback) {
+    const result = function (input: z.input<typeof arg1>): ReturnType<Callback> {
+        const parsed = arg1.parse(input);
+        return cb.apply(cb, [parsed as any]);
+    };
+    result.schema = arg1;
+    return result;
+}
+
+export function doubleFn<
+    Arg1 extends ZodSchema,
+    Arg2 extends ZodSchema,
+    Callback extends (arg1: z.output<Arg1>, arg2: z.output<Arg2>) => any,
+>(arg1: Arg1, arg2: Arg2, cb: Callback) {
+    const result = function (input: z.input<typeof arg1>, input2: z.input<typeof arg2>): ReturnType<Callback> {
+        const parsed = arg1.parse(input);
+        const parsed2 = arg2.parse(input2);
+        return cb.apply(cb, [parsed as any, parsed2 as any]);
+    };
+    result.schema = arg1;
+    return result;
+}

cloud/packages/core/src/utils/helper.ts

@@ -0,0 +1,10 @@
+export function chunkArray<T>(arr: T[], chunkSize: number): T[][] {
+    if (chunkSize <= 0) {
+        throw new Error("chunkSize must be a positive integer");
+    }
+    const chunks: T[][] = [];
+    for (let i = 0; i < arr.length; i += chunkSize) {
+        chunks.push(arr.slice(i, i + chunkSize));
+    }
+    return chunks;
+}

cloud/packages/core/src/utils/id.ts

@@ -0,0 +1,33 @@
+import { ulid } from "ulid";
+
+export const prefixes = {
+  user: "usr",
+  credentials:"crd",
+  team: "tem",
+  product: "prd",
+  session: "ses",
+  machine: "mch",
+  member: "mbr",
+  variant: "var",
+  gpu: "gpu",
+  game: "gme",
+  usage: "usg",
+  subscription: "sub",
+  // task: "tsk",
+  // invite: "inv",
+  // product: "prd",
+} as const;
+
+/**
+ * Generates a unique identifier by concatenating a predefined prefix with a ULID.
+ *
+ * Given a key from the predefined prefixes mapping (e.g., "user", "team", "member", "steam"),
+ * this function retrieves the corresponding prefix and combines it with a ULID using an underscore
+ * as a separator. The resulting identifier is formatted as "prefix_ulid".
+ *
+ * @param prefix - A key from the prefixes mapping.
+ * @returns A unique identifier string.
+ */
+export function createID(prefix: keyof typeof prefixes): string {
+  return [prefixes[prefix], ulid()].join("_");
+}

cloud/packages/core/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from "./id"
+export * from "./fn"
+export * from "./log"
+export * from "./invite"
+export * from "./helper"

cloud/packages/core/src/utils/invite.ts

@@ -0,0 +1,32 @@
+export namespace Invite {
+    /**
+     * Generates a random invite code for teams
+     * @param length The length of the invite code (default: 8)
+     * @returns A string containing alphanumeric characters (excluding confusing characters)
+     */
+    export function generateCode(length: number = 8): string {
+        // Use only unambiguous characters (no 0/O, 1/l/I confusion)
+        const characters = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+        let result = '';
+
+        // Create a Uint32Array of the required length for randomness
+        const randomValues = new Uint32Array(length);
+
+        // Fill with cryptographically strong random values if available
+        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+            crypto.getRandomValues(randomValues);
+        } else {
+            // Fallback for environments without crypto
+            for (let i = 0; i < length; i++) {
+                randomValues[i] = Math.floor(Math.random() * 2 ** 32);
+            }
+        }
+
+        // Use the random values to select characters
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(randomValues[i] % characters.length);
+        }
+
+        return result;
+    }
+}

cloud/packages/core/src/utils/log.ts

@@ -0,0 +1,76 @@
+import { createContext } from "../context";
+
+export namespace Log {
+  const ctx = createContext<{
+    tags: Record<string, any>;
+  }>();
+
+  export function create(tags?: Record<string, any>) {
+    tags = tags || {};
+
+    const result = {
+      info(msg: string, extra?: Record<string, any>) {
+        const prefix = Object.entries({
+          ...use().tags,
+          ...tags,
+          ...extra,
+        })
+          .map(([key, value]) => `${key}=${value}`)
+          .join(" ");
+        console.log(prefix, msg);
+        return result;
+      },
+      warn(msg: string, extra?: Record<string, any>) {
+        const prefix = Object.entries({
+          ...use().tags,
+          ...tags,
+          ...extra,
+        })
+          .map(([key, value]) => `${key}=${value}`)
+          .join(" ");
+        console.warn(prefix, msg);
+        return result;
+      },
+      error(error: Error) {
+        const prefix = Object.entries({
+          ...use().tags,
+          ...tags,
+        })
+          .map(([key, value]) => `${key}=${value}`)
+          .join(" ");
+        console.error(prefix, error);
+        return result;
+      },
+      tag(key: string, value: string) {
+         // Immutable update: return a fresh logger with updated tags
+        return Log.create({ ...tags, [key]: value });
+      },
+      clone() {
+        return Log.create({ ...tags });
+      },
+    };
+
+    return result;
+  }
+
+  export function provide<R>(tags: Record<string, any>, cb: () => R) {
+    const existing = use();
+    return ctx.provide(
+      {
+        tags: {
+          ...existing.tags,
+          ...tags,
+        },
+      },
+      cb,
+    );
+  }
+
+  function use() {
+    try {
+      return ctx.use();
+    } catch (e) {
+      return { tags: {} };
+    }
+  }
+}