@fragno-dev/db 0.1.15 → 0.2.0

package/src/schema/serialize.ts

@@ -1,407 +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
- *
- * @param skipDriverConversions - Skip driver-level type conversions (Date->number, boolean->0/1, bigint->Buffer).
- *                                 Set to true when using ORMs like Drizzle that handle these conversions internally.
- */
-export function serialize(
-  value: unknown,
-  col: AnyColumn,
-  provider: SQLProvider,
-  skipDriverConversions = false,
-) {
-  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);
-  }
-
-  // Skip driver-specific type conversions when using ORMs that handle them internally
-  if (!skipDriverConversions) {
-    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;
-}