@sedrino/db-schema 0.1.1

package/src/utils.ts

@@ -0,0 +1,286 @@
+import type {
+  DatabaseSchemaDocument,
+  DefaultSpec,
+  FieldSpec,
+  LogicalTypeSpec,
+  SchemaValidationIssue,
+  StorageSpec,
+} from "./types";
+
+const SQLITE_EPOCH_MS_NOW =
+  "CAST(strftime('%s','now') AS integer) * 1000 + CAST((strftime('%f','now') - strftime('%S','now')) * 1000 AS integer)";
+
+export function sqliteEpochMsNowSql() {
+  return SQLITE_EPOCH_MS_NOW;
+}
+
+export function toSnakeCase(value: string) {
+  return value
+    .replace(/-/g, "_")
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1_$2")
+    .toLowerCase();
+}
+
+export function toPascalCase(value: string) {
+  return value
+    .replace(/[_-]+/g, " ")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((part) => `${part[0]!.toUpperCase()}${part.slice(1)}`)
+    .join("");
+}
+
+export function quoteIdentifier(value: string) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+export function tableVariableName(tableName: string) {
+  return `table${toPascalCase(tableName)}`;
+}
+
+export function fieldAutoId(tableName: string, fieldName: string) {
+  return `fld_${toSnakeCase(tableName)}_${toSnakeCase(fieldName)}`;
+}
+
+export function tableAutoId(tableName: string) {
+  return `tbl_${toSnakeCase(tableName)}`;
+}
+
+export function defaultStorageForLogical(logical: LogicalTypeSpec, column: string): StorageSpec {
+  switch (logical.kind) {
+    case "id":
+    case "string":
+    case "text":
+    case "enum":
+    case "json":
+      return { strategy: "sqlite.text", column };
+    case "boolean":
+    case "integer":
+      return { strategy: "sqlite.integer", column };
+    case "number":
+      return { strategy: "sqlite.real", column };
+    case "temporal.instant":
+      return { strategy: "sqlite.temporalInstantEpochMs", column };
+    case "temporal.plainDate":
+      return { strategy: "sqlite.temporalPlainDateText", column };
+  }
+}
+
+export function validateLogicalAndStorageCompatibility(
+  logical: LogicalTypeSpec,
+  storage: StorageSpec,
+): string | null {
+  switch (storage.strategy) {
+    case "sqlite.temporalInstantEpochMs":
+      return logical.kind === "temporal.instant"
+        ? null
+        : "sqlite.temporalInstantEpochMs storage requires logical kind temporal.instant";
+    case "sqlite.temporalPlainDateText":
+      return logical.kind === "temporal.plainDate"
+        ? null
+        : "sqlite.temporalPlainDateText storage requires logical kind temporal.plainDate";
+    case "sqlite.integer":
+      return logical.kind === "boolean" || logical.kind === "integer"
+        ? null
+        : "sqlite.integer storage requires logical kind boolean or integer";
+    case "sqlite.real":
+      return logical.kind === "number" ? null : "sqlite.real storage requires logical kind number";
+    case "sqlite.text":
+      return logical.kind === "id" ||
+        logical.kind === "string" ||
+        logical.kind === "text" ||
+        logical.kind === "enum" ||
+        logical.kind === "json"
+        ? null
+        : "sqlite.text storage requires logical kind id, string, text, enum, or json";
+  }
+}
+
+export function validateDefaultCompatibility(
+  field: FieldSpec,
+  defaultValue: DefaultSpec,
+): string | null {
+  if (defaultValue.kind === "generatedId") {
+    return field.logical.kind === "id" ? null : "generatedId default requires logical kind id";
+  }
+
+  if (defaultValue.kind === "now") {
+    return field.logical.kind === "temporal.instant"
+      ? null
+      : "now default requires logical kind temporal.instant";
+  }
+
+  if (field.logical.kind === "boolean" && typeof defaultValue.value !== "boolean") {
+    return "boolean fields require boolean literal defaults";
+  }
+
+  if (field.logical.kind === "integer" && !Number.isInteger(defaultValue.value)) {
+    return "integer fields require integer literal defaults";
+  }
+
+  if (field.logical.kind === "number" && typeof defaultValue.value !== "number") {
+    return "number fields require numeric literal defaults";
+  }
+
+  return null;
+}
+
+export function validateSchemaDocumentCompatibility(
+  schema: DatabaseSchemaDocument,
+): SchemaValidationIssue[] {
+  const issues: SchemaValidationIssue[] = [];
+  const tableNames = new Set<string>();
+
+  for (const table of schema.tables) {
+    if (tableNames.has(table.name)) {
+      issues.push({
+        path: `tables.${table.name}`,
+        message: `Duplicate table name ${table.name}`,
+      });
+    }
+    tableNames.add(table.name);
+
+    const fieldNames = new Set<string>();
+    let primaryKeyCount = 0;
+
+    for (const field of table.fields) {
+      if (fieldNames.has(field.name)) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: `Duplicate field name ${field.name}`,
+        });
+      }
+      fieldNames.add(field.name);
+
+      if (field.primaryKey) primaryKeyCount += 1;
+      if (field.primaryKey && field.nullable) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: "Primary key fields cannot be nullable",
+        });
+      }
+
+      const storageIssue = validateLogicalAndStorageCompatibility(field.logical, field.storage);
+      if (storageIssue) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: storageIssue,
+        });
+      }
+
+      if (field.default) {
+        const defaultIssue = validateDefaultCompatibility(field, field.default);
+        if (defaultIssue) {
+          issues.push({
+            path: `tables.${table.name}.fields.${field.name}`,
+            message: defaultIssue,
+          });
+        }
+      }
+
+      if (field.references && !tableNames.has(field.references.table)) {
+        const targetTableExists = schema.tables.some(
+          (candidate) => candidate.name === field.references!.table,
+        );
+        if (!targetTableExists) {
+          issues.push({
+            path: `tables.${table.name}.fields.${field.name}`,
+            message: `Referenced table ${field.references.table} does not exist`,
+          });
+        }
+      }
+
+      if (field.references) {
+        const targetTable = schema.tables.find(
+          (candidate) => candidate.name === field.references!.table,
+        );
+        const targetFieldExists = targetTable?.fields.some(
+          (candidate) => candidate.name === field.references!.field,
+        );
+
+        if (targetTable && !targetFieldExists) {
+          issues.push({
+            path: `tables.${table.name}.fields.${field.name}`,
+            message: `Referenced field ${field.references.field} does not exist on table ${field.references.table}`,
+          });
+        }
+      }
+    }
+
+    if (primaryKeyCount > 1) {
+      issues.push({
+        path: `tables.${table.name}`,
+        message: "Composite primary keys are not supported in v1",
+      });
+    }
+
+    for (const index of table.indexes) {
+      for (const fieldName of index.fields) {
+        if (!fieldNames.has(fieldName)) {
+          issues.push({
+            path: `tables.${table.name}.indexes.${index.name ?? fieldName}`,
+            message: `Index references missing field ${fieldName}`,
+          });
+        }
+      }
+    }
+
+    for (const unique of table.uniques) {
+      for (const fieldName of unique.fields) {
+        if (!fieldNames.has(fieldName)) {
+          issues.push({
+            path: `tables.${table.name}.uniques.${unique.name ?? fieldName}`,
+            message: `Unique constraint references missing field ${fieldName}`,
+          });
+        }
+      }
+    }
+  }
+
+  return issues;
+}
+
+export function stableStringify(value: unknown): string {
+  return JSON.stringify(sortValue(value));
+}
+
+function sortValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sortValue(entry));
+  }
+
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value as Record<string, unknown>)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, innerValue]) => [key, sortValue(innerValue)]);
+    return Object.fromEntries(entries);
+  }
+
+  return value;
+}
+
+export function createSchemaHash(schema: DatabaseSchemaDocument) {
+  const text = stableStringify(schema);
+  let hash = 2166136261;
+
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+
+  return `schema_${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+
+export function cloneSchema<T>(value: T): T {
+  return structuredClone(value);
+}
+
+export function renameStorageColumn(field: FieldSpec, newFieldName: string): FieldSpec {
+  const next = cloneSchema(field);
+  const column = toSnakeCase(newFieldName);
+  next.name = newFieldName;
+  next.storage = { ...next.storage, column };
+  return next;
+}