@fragno-dev/db 0.1.14 → 0.2.0

package/src/schema/serialize.ts

@@ -1,396 +0,0 @@
-import type { SQLProvider } from "../shared/providers";
-import type { AnyColumn } from "./create";
-import { FragnoId, FragnoReference } from "./create";
-
-export interface AdditionalColumnMetadata {
-  length?: number;
-  precision?: number;
-  scale?: number;
-}
-
-/**
- * Get the possible column types that the raw DB type can map to.
- */
-export function dbToSchemaType(
-  dbType: string,
-  provider: SQLProvider,
-  additional: AdditionalColumnMetadata,
-): (AnyColumn["type"] | "varchar(n)")[] {
-  dbType = dbType.toLowerCase();
-  if (provider === "sqlite") {
-    switch (dbType) {
-      case "integer":
-        return ["bool", "date", "timestamp", "bigint", "integer"];
-      case "text":
-        return ["json", "string", "bigint", "varchar(n)"];
-      case "real":
-      case "numeric":
-        return ["decimal"];
-      case "blob":
-        return ["bigint", "binary"];
-      default:
-        return [dbType as AnyColumn["type"]];
-    }
-  }
-
-  if (provider === "postgresql" || provider === "cockroachdb") {
-    switch (dbType) {
-      case "decimal":
-      case "real":
-      case "numeric":
-      case "double precision":
-        return ["decimal"];
-      case "timestamp":
-      case "timestamptz":
-        return ["timestamp"];
-      case "varchar": {
-        const len = additional.length;
-        if (len != null) {
-          return [`varchar(${len})`];
-        }
-        return ["string"];
-      }
-      case "text":
-        return ["string"];
-      case "boolean":
-      case "bool":
-        return ["bool"];
-      case "bytea":
-        return ["binary"];
-      default:
-        return [dbType as AnyColumn["type"]];
-    }
-  }
-
-  if (provider === "mysql") {
-    switch (dbType) {
-      case "bool":
-      case "boolean":
-        return ["bool"];
-      case "integer":
-      case "int":
-        return ["integer"];
-      case "decimal":
-      case "numeric":
-      case "float":
-      case "double":
-        return ["decimal"];
-      case "datetime":
-        return ["timestamp"];
-      case "varchar": {
-        const len = additional.length;
-        if (len != null) {
-          return [`varchar(${len})`];
-        }
-        return ["string"];
-      }
-      case "text":
-        return ["string"];
-      case "longblob":
-      case "blob":
-      case "mediumblob":
-      case "tinyblob":
-        return ["binary"];
-      default:
-        return [dbType as AnyColumn["type"]];
-    }
-  }
-
-  if (provider === "mssql") {
-    switch (dbType) {
-      case "int":
-        return ["integer"];
-      case "decimal":
-      case "float":
-      case "real":
-      case "numeric":
-        return ["decimal"];
-      case "bit":
-        return ["bool"];
-      case "datetime":
-      case "datetime2":
-        return ["timestamp"];
-      case "nvarchar":
-      case "varchar": {
-        const len = additional.length;
-        if (len != null) {
-          return [`varchar(${len})`];
-        }
-        return ["string", "json"];
-      }
-      case "ntext":
-      case "text":
-      case "varchar(max)":
-      case "nvarchar(max)":
-        return ["string", "json"];
-      case "binary":
-      case "varbinary":
-        return ["binary"];
-      default:
-        return [dbType as AnyColumn["type"]];
-    }
-  }
-
-  throw new Error(`unhandled database provider: ${provider}`);
-}
-
-/**
- * Database type literals that can be returned by schemaToDBType
- */
-export type DBTypeLiteral =
-  // PostgreSQL/CockroachDB types
-  | "bigserial"
-  | "serial"
-  | "boolean"
-  | "bool"
-  | "json"
-  | "text"
-  | "bytea"
-  | "timestamp"
-  | "timestamptz"
-  | "bigint"
-  | "integer"
-  | "decimal"
-  | "date"
-  // MySQL types
-  | "longblob"
-  | "datetime"
-  // SQLite types
-  | "blob"
-  | "real"
-  // MSSQL types
-  | "bit"
-  | "int"
-  | "varbinary(max)"
-  | "varchar(max)"
-  // varchar with length parameter
-  | `varchar(${number})`;
-
-export function schemaToDBType(
-  column: AnyColumn | Pick<AnyColumn, "type">,
-  provider: SQLProvider,
-): DBTypeLiteral {
-  const { type } = column;
-
-  // Handle internal ID columns with auto-increment
-  if ("role" in column && column.role === "internal-id") {
-    if (provider === "postgresql" || provider === "cockroachdb") {
-      return "bigserial";
-    }
-    if (provider === "mysql") {
-      return "bigint";
-    }
-    if (provider === "sqlite") {
-      return "integer"; // SQLite uses INTEGER for auto-increment
-    }
-    if (provider === "mssql") {
-      return "bigint";
-    }
-  }
-
-  if ("role" in column && column.role === "reference") {
-    if (provider === "sqlite") {
-      return "integer";
-    }
-    // Other providers use bigint for references
-  }
-
-  if (provider === "sqlite") {
-    switch (type) {
-      case "integer":
-      case "timestamp":
-      case "date":
-      case "bool":
-        return "integer";
-      case "binary":
-      case "bigint":
-        return "blob";
-      case "json":
-      case "string":
-        return "text";
-      case "decimal":
-        return "real";
-      default:
-        // sqlite doesn't support varchar
-        if (type.startsWith("varchar")) {
-          return "text";
-        }
-    }
-  }
-
-  if (provider === "mssql") {
-    switch (type) {
-      case "bool":
-        return "bit";
-      case "timestamp":
-        return "datetime";
-      case "integer":
-        return "int";
-      case "string":
-        return "varchar(max)";
-      case "binary":
-        return "varbinary(max)";
-      // only 2025 preview supports JSON natively
-      case "json":
-        return "varchar(max)";
-      default:
-        if (type.startsWith("varchar")) {
-          return type as `varchar(${number})`;
-        }
-        return type;
-    }
-  }
-
-  if (provider === "postgresql" || provider === "cockroachdb") {
-    switch (type) {
-      case "bool":
-        return "boolean";
-      case "json":
-        return "json";
-      case "string":
-        return "text";
-      case "binary":
-        return "bytea";
-      default:
-        if (type.startsWith("varchar")) {
-          return type as `varchar(${number})`;
-        }
-        return type;
-    }
-  }
-
-  if (provider === "mysql") {
-    switch (type) {
-      case "bool":
-        return "boolean";
-      case "string":
-        return "text";
-      case "binary":
-        return "longblob";
-      default:
-        if (type.startsWith("varchar")) {
-          return type as `varchar(${number})`;
-        }
-        return type;
-    }
-  }
-
-  throw new Error(`cannot handle ${provider} ${type}`);
-}
-
-const supportJson: SQLProvider[] = ["postgresql", "cockroachdb", "mysql"];
-
-/**
- * Parse from driver value
- */
-export function deserialize(value: unknown, col: AnyColumn, provider: SQLProvider) {
-  if (value === null) {
-    return null;
-  }
-
-  if (!supportJson.includes(provider) && col.type === "json" && typeof value === "string") {
-    return JSON.parse(value);
-  }
-
-  if (
-    provider === "sqlite" &&
-    (col.type === "timestamp" || col.type === "date") &&
-    (typeof value === "number" || typeof value === "string")
-  ) {
-    return new Date(value);
-  }
-
-  if (
-    (provider === "postgresql" || provider === "cockroachdb") &&
-    (col.type === "timestamp" || col.type === "date") &&
-    typeof value === "string"
-  ) {
-    return new Date(value);
-  }
-
-  if (
-    provider === "mysql" &&
-    (col.type === "timestamp" || col.type === "date") &&
-    typeof value === "string"
-  ) {
-    return new Date(value);
-  }
-
-  if (col.type === "bool" && typeof value === "number") {
-    return value === 1;
-  }
-
-  if (col.type === "bigint" && value instanceof Buffer) {
-    return value.readBigInt64BE(0);
-  }
-
-  if (col.type === "bigint" && typeof value === "string") {
-    return BigInt(value);
-  }
-
-  if (col.type === "binary" && value instanceof Buffer) {
-    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  }
-
-  return value;
-}
-
-/**
- * Encode to driver value
- */
-export function serialize(value: unknown, col: AnyColumn, provider: SQLProvider) {
-  if (value === null) {
-    return null;
-  }
-
-  // Handle FragnoReference objects (for reference columns)
-  if (value instanceof FragnoReference) {
-    return value.internalId;
-  }
-
-  // Handle FragnoId objects
-  if (value instanceof FragnoId) {
-    // For external ID columns, use the external ID
-    if (col.role === "external-id") {
-      return value.externalId;
-    }
-    // For internal ID columns, use the internal ID (must be present)
-    if (col.role === "internal-id") {
-      if (!value.internalId) {
-        throw new Error(`FragnoId must have internalId for internal-id column ${col.name}`);
-      }
-      return value.internalId;
-    }
-    // For reference columns, prefer internal ID if available
-    if (col.role === "reference") {
-      return value.databaseId;
-    }
-    // Default to external ID for other columns
-    return value.externalId;
-  }
-
-  if (!supportJson.includes(provider) && col.type === "json") {
-    return JSON.stringify(value);
-  }
-
-  if (provider === "sqlite" && value instanceof Date) {
-    return value.getTime();
-  }
-
-  if (provider === "sqlite" && typeof value === "boolean") {
-    return value ? 1 : 0;
-  }
-
-  if (provider === "sqlite" && typeof value === "bigint") {
-    const buf = Buffer.alloc(8);
-    buf.writeBigInt64BE(value);
-    return buf;
-  }
-
-  // most drivers accept Buffer
-  if (col.type === "binary" && value instanceof Uint8Array) {
-    return Buffer.from(value);
-  }
-
-  return value;
-}

package/src/shared/settings-schema.ts

@@ -1,61 +0,0 @@
-import type { AbstractQuery } from "../query/query";
-import { schema, idColumn, column, type FragnoId } from "../schema/create";
-
-export const SETTINGS_TABLE_NAME = "fragno_db_settings" as const;
-export const SETTINGS_NAMESPACE = "fragno-db-settings" as const;
-
-export const settingsSchema = schema((s) => {
-  return s.addTable(SETTINGS_TABLE_NAME, (t) => {
-    return t
-      .addColumn("id", idColumn())
-      .addColumn("key", column("string"))
-      .addColumn("value", column("string"))
-      .createIndex("unique_key", ["key"], { unique: true });
-  });
-});
-
-export function createSettingsManager(
-  // oxlint-disable-next-line no-explicit-any
-  queryEngine: AbstractQuery<typeof settingsSchema, any>,
-  namespace: string,
-) {
-  return {
-    async get(key: string): Promise<{ id: FragnoId; key: string; value: string } | undefined> {
-      const uow = queryEngine
-        .createUnitOfWork()
-        .find(SETTINGS_TABLE_NAME, (b) =>
-          b.whereIndex("unique_key", (eb) => eb("key", "=", `${namespace}.${key}`)),
-        );
-      const [[result]] = await uow.executeRetrieve();
-      return result; // Safe: result can be undefined if key doesn't exist
-    },
-
-    async set(key: string, value: string) {
-      const uow = queryEngine
-        .createUnitOfWork("createSettingsManager#set")
-        .find(SETTINGS_TABLE_NAME, (b) =>
-          b.whereIndex("unique_key", (eb) => eb("key", "=", `${namespace}.${key}`)),
-        );
-      const [[existing]] = await uow.executeRetrieve();
-
-      if (existing) {
-        uow.update(SETTINGS_TABLE_NAME, existing.id, (b) => b.set({ value }).check());
-      } else {
-        uow.create(SETTINGS_TABLE_NAME, {
-          key: `${namespace}.${key}`,
-          value,
-        });
-      }
-
-      const { success } = await uow.executeMutations();
-
-      if (!success) {
-        throw new Error("Failed to set schema version");
-      }
-    },
-
-    async delete(id: FragnoId) {
-      await queryEngine.delete(SETTINGS_TABLE_NAME, id);
-    },
-  };
-}

package/src/uow-context-integration.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { defineFragmentWithDatabase } from "./fragment";
-import { createFragment } from "@fragno-dev/core";
-import { schema, column, idColumn } from "./schema/create";
-
-describe("UOW Context Integration", () => {
-  it("should bind services to use serviceContext", () => {
-    // Create a schema
-    const testSchema = schema((s) => {
-      return s.addTable("user", (t) => {
-        return t.addColumn("id", idColumn()).addColumn("name", column("string"));
-      });
-    });
-
-    // Define fragment with service that uses this.getUnitOfWork()
-    const fragmentDef = defineFragmentWithDatabase<{}>("test-fragment")
-      .withDatabase(testSchema, "test")
-      .providesService(({ defineService }) =>
-        defineService({
-          createUser: function (name: string) {
-            const uow = this.getUnitOfWork(testSchema);
-            const userId = uow.create("user", { name });
-            return { userId: userId.valueOf(), name };
-          },
-        }),
-      );
-
-    // Mock database adapter
-    const mockSchemaView = {
-      create: () => ({ valueOf: () => 1 }),
-    };
-    const mockUow = {
-      forSchema: () => mockSchemaView,
-    };
-    const mockAdapter = {
-      createQueryEngine: () => ({
-        createUnitOfWork: () => mockUow,
-      }),
-    };
-
-    // Create fragment instance - services should be bound
-    const fragment = createFragment(fragmentDef, {}, [], {
-      mountRoute: "/api/test",
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      databaseAdapter: mockAdapter as any,
-    });
-
-    // Verify services are defined
-    expect(fragment.services).toBeDefined();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect((fragment.services as any).createUser).toBeDefined();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(typeof (fragment.services as any).createUser).toBe("function");
-  });
-
-  it("should bind providesService services properly", () => {
-    const schema1 = schema((s) => {
-      return s.addTable("post", (t) => {
-        return t.addColumn("id", idColumn()).addColumn("title", column("string"));
-      });
-    });
-
-    // Fragment with providesService
-    const fragmentDef = defineFragmentWithDatabase<{}>("fragment1")
-      .withDatabase(schema1, "fragment1")
-      .providesService(({ defineService }) =>
-        defineService({
-          createPost: function (title: string) {
-            const uow = this.getUnitOfWork(schema1);
-            const postId = uow.create("post", { title });
-            return { postId: postId.valueOf(), title };
-          },
-        }),
-      );
-
-    // Mock adapter
-    const mockSchemaView = {
-      create: () => ({ valueOf: () => 2 }),
-    };
-    const mockUow = {
-      forSchema: () => mockSchemaView,
-    };
-    const mockAdapter = {
-      createQueryEngine: () => ({
-        createUnitOfWork: () => mockUow,
-      }),
-    };
-
-    // Create fragment
-    const fragment = createFragment(fragmentDef, {}, [], {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      databaseAdapter: mockAdapter as any,
-    });
-
-    // Verify service is properly bound
-    expect(fragment.services).toBeDefined();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect((fragment.services as any).createPost).toBeDefined();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(typeof (fragment.services as any).createPost).toBe("function");
-  });
-});