@fragno-dev/db 0.2.0 → 0.2.2

package/src/schema/generate-id.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { schema, idColumn, FragnoId } from "./create";
+import { generateId } from "./generate-id";
+
+describe("generateId", () => {
+  const testSchema = schema((s) =>
+    s.addTable("users", (t) =>
+      t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),
+    ),
+  );
+
+  it("should generate a new FragnoId", () => {
+    const id = generateId(testSchema, "users");
+
+    expect(id).toBeInstanceOf(FragnoId);
+    expect(id.externalId).toBeDefined();
+    expect(typeof id.externalId).toBe("string");
+    expect(id.externalId.length).toBeGreaterThan(0);
+    expect(id.version).toBe(0);
+  });
+
+  it("should generate unique IDs on each call", () => {
+    const id1 = generateId(testSchema, "users");
+    const id2 = generateId(testSchema, "users");
+
+    expect(id1.externalId).not.toBe(id2.externalId);
+  });
+
+  it("should throw for non-existent table", () => {
+    expect(() => {
+      // @ts-expect-error - testing runtime error for non-existent table
+      generateId(testSchema, "nonexistent");
+    }).toThrow("Table nonexistent not found in schema");
+  });
+
+  it("should work with multiple tables", () => {
+    const multiTableSchema = schema((s) =>
+      s
+        .addTable("users", (t) =>
+          t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),
+        )
+        .addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("title", "string")
+            .addColumn("authorId", "string"),
+        ),
+    );
+
+    const userId = generateId(multiTableSchema, "users");
+    const postId = generateId(multiTableSchema, "posts");
+
+    expect(userId).toBeInstanceOf(FragnoId);
+    expect(postId).toBeInstanceOf(FragnoId);
+    expect(userId.externalId).not.toBe(postId.externalId);
+  });
+});

package/src/schema/generate-id.ts

@@ -0,0 +1,38 @@
+import type { AnySchema } from "./create";
+import { FragnoId } from "./create";
+
+/**
+ * Generate a new ID for a table without creating a record.
+ * This is useful when you need to reference an ID before actually creating the record,
+ * or when you need to pass the ID to external services.
+ *
+ * @example
+ * ```ts
+ * const userId = generateId(mySchema, "users");
+ * // Use userId in related records or pass to external services
+ * uow.create("users", { id: userId, name: "John" });
+ * ```
+ */
+export function generateId<
+  TSchema extends AnySchema,
+  TableName extends keyof TSchema["tables"] & string,
+>(schema: TSchema, tableName: TableName): FragnoId {
+  const tableSchema = schema.tables[tableName];
+  if (!tableSchema) {
+    throw new Error(`Table ${tableName} not found in schema`);
+  }
+
+  const idColumn = tableSchema.getIdColumn();
+  const generated = idColumn.generateDefaultValue();
+  if (generated === undefined) {
+    throw new Error(`ID column ${idColumn.ormName} on table ${tableName} has no default generator`);
+  }
+
+  if (typeof generated !== "string") {
+    throw new Error(
+      `ID column ${idColumn.ormName} on table ${tableName} has no default generator that generates a string.`,
+    );
+  }
+
+  return FragnoId.fromExternal(generated, 0);
+}

package/src/shared/config.ts

@@ -1,10 +0,0 @@
-import type { AnySchema } from "../schema/create";
-
-export interface LibraryConfig<TSchemas extends AnySchema[] = AnySchema[]> {
-  namespace: string;
-
-  /**
-   * different versions of schemas (sorted in ascending order)
-   */
-  schemas: TSchemas;
-}

package/src/shared/connection-pool.ts

@@ -1,24 +0,0 @@
-/**
- * Represents an active database connection that can be released back to the pool.
- */
-export interface Connection<TDatabase> {
-  db: TDatabase;
-  release(): Promise<void>;
-}
-
-/**
- * Connection pool interface for managing database connections.
- * Adapter-specific implementations should be used (e.g., createKyselyConnectionPool, createDrizzleConnectionPool).
- */
-export interface ConnectionPool<TDatabase> {
-  /** Acquire a connection from the pool */
-  connect(): Promise<Connection<TDatabase>>;
-  /**
-   * Get the database instance synchronously. Only works if the pool has already been initialized
-   * via connect().
-   * @throws an error if called before the pool is initialized.
-   */
-  getDatabaseSync(): TDatabase;
-  /** Close the pool and cleanup resources */
-  close(): Promise<void>;
-}

package/src/shared/prisma.ts

@@ -1,45 +0,0 @@
-export type PrismaClient = Record<
-  string,
-  {
-    count: (options: {
-      select: Record<string, unknown>;
-      where?: object;
-    }) => Promise<Record<string, number>>;
-    upsert: (options: {
-      where: object;
-      update: Record<string, unknown>;
-      create: Record<string, unknown>;
-    }) => Promise<void>;
-
-    create: (options: { data: Record<string, unknown> }) => Promise<Record<string, unknown>>;
-
-    createMany: (options: { data: Record<string, unknown>[] }) => Promise<void>;
-
-    delete: (options: { where: object }) => Promise<Record<string, unknown>>;
-
-    deleteMany: (options: { where?: object }) => Promise<void>;
-
-    findFirst: (options: {
-      where: object;
-      select?: Record<string, unknown>;
-      orderBy?: OrderBy | OrderBy[];
-      skip?: number;
-    }) => Promise<Record<string, unknown> | null>;
-
-    findMany: (options: {
-      where?: object;
-      select?: Record<string, unknown>;
-      orderBy?: OrderBy | OrderBy[];
-      skip?: number;
-      take?: number;
-    }) => Promise<Record<string, unknown>[]>;
-
-    updateMany: (options: { where?: object; data: Record<string, unknown> }) => Promise<void>;
-  }
-> & {
-  $transaction: <T>(v: (tx: PrismaClient) => T | Promise<T>) => Promise<T>;
-};
-
-export type OrderBy = {
-  [k: string]: "asc" | "desc" | OrderBy;
-};