@fragno-dev/db 0.0.1 → 0.1.0

package/src/schema/serialize.ts

@@ -0,0 +1,359 @@
+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 (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 (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/schema-generator/schema-generator.ts

@@ -0,0 +1,12 @@
+export interface GenerateSchemaOptions {
+  path: string;
+  toVersion?: number;
+  fromVersion?: number;
+}
+
+export interface SchemaGenerator {
+  generateSchema: (options?: GenerateSchemaOptions) => {
+    schema: string;
+    path: string;
+  };
+}

package/src/shared/config.ts

@@ -1,5 +1,3 @@
-import type { Kysely } from "kysely";
-import type { SQLProvider } from "./providers";
 import type { AnySchema } from "../schema/create";
 
 export interface LibraryConfig<TSchemas extends AnySchema[] = AnySchema[]> {
@@ -10,9 +8,3 @@ export interface LibraryConfig<TSchemas extends AnySchema[] = AnySchema[]> {
    */
   schemas: TSchemas;
 }
-
-export interface KyselyConfig {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  db: Kysely<any>;
-  provider: SQLProvider;
-}

package/src/util/import-generator.ts

@@ -0,0 +1,28 @@
+export function importGenerator() {
+  const names = new Set<string>();
+  // specifier -> import name
+  const map = new Map<string, string[]>();
+
+  return {
+    addImport(name: string, specifier: string) {
+      if (names.has(name)) {
+        return;
+      }
+
+      names.add(name);
+      const list = map.get(specifier) ?? [];
+      list.push(name);
+      map.set(specifier, list);
+    },
+    format(): string {
+      const v: string[] = [];
+      for (const [specifier, names] of map) {
+        if (names.length === 0) continue;
+
+        v.push(`import { ${names.join(", ")} } from "${specifier}"`);
+      }
+
+      return v.join("\n");
+    },
+  };
+}

package/src/util/parse.ts

@@ -0,0 +1,16 @@
+const RegexVarchar = /^varchar\((\d+)\)$/;
+
+export function parseVarchar(template: string): number {
+  const match = RegexVarchar.exec(template);
+  if (!match) throw new Error("Failed to match varchar(n)");
+  return Number(match[1]);
+}
+
+export function ident(s: string, identation = 2): string {
+  const tab = " ".repeat(identation);
+
+  return s
+    .split("\n")
+    .map((v) => tab + v)
+    .join("\n");
+}

package/src/util/types.ts

@@ -0,0 +1,4 @@
+/**
+ * Forces TypeScript to simplify/flatten complex intersection types for better display in IDE hovers
+ */
+export type Prettify<T> = { [K in keyof T]: T[K] } & {};

package/tsconfig.json

@@ -6,5 +6,5 @@
     "composite": true
   },
   "include": ["src"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "**/_generated"]
 }

package/tsdown.config.ts

@@ -1,7 +1,17 @@
 import { defineConfig } from "tsdown";
 
 export default defineConfig({
-  entry: ["./src/mod.ts", "./src/schema/create.ts"],
+  entry: [
+    "./src/mod.ts",
+    "./src/id.ts",
+    "./src/schema/create.ts",
+    "./src/query/query.ts",
+    "./src/adapters/kysely/kysely-adapter.ts",
+    "./src/adapters/drizzle/drizzle-adapter.ts",
+    "./src/query/unit-of-work.ts",
+    "./src/query/cursor.ts",
+    "./src/fragment.ts",
+  ],
   dts: true,
   unbundle: true,
 });

package/vitest.config.ts

@@ -1,7 +1,10 @@
 import { defineConfig } from "vitest/config";
+import { baseConfig } from "@fragno-private/vitest-config";
 
 export default defineConfig({
+  ...baseConfig,
   test: {
+    ...baseConfig.test,
     environment: "node",
   },
 });