bazis 0.96.1

package/library/orm/Schema/CheckExpression.ts

@@ -0,0 +1,327 @@
+import { ModelBuildError } from "../errors";
+import type { PropertyModel } from "../Metadata/types";
+export type CheckScalar = null | boolean | number | string;
+export type CheckAst = {
+  readonly kind: "compare";
+  readonly op: "=" | "<>" | ">" | ">=" | "<" | "<=";
+  readonly left: string;
+  readonly right: string | CheckScalar;
+} | {
+  readonly kind: "in";
+  readonly left: string;
+  readonly values: readonly CheckScalar[];
+} | {
+  readonly kind: "null";
+  readonly left: string;
+  readonly not: boolean;
+} | {
+  readonly kind: "and" | "or";
+  readonly left: CheckAst;
+  readonly right: CheckAst;
+} | {
+  readonly kind: "not";
+  readonly inner: CheckAst;
+};
+export interface CheckExpression {
+  readonly ast: CheckAst;
+  and(other: CheckExpression): CheckExpression;
+  or(other: CheckExpression): CheckExpression;
+  not(): CheckExpression;
+}
+export interface CheckOperand<T = unknown> {
+  eq(value: CheckOperand<T> | T | null): CheckExpression;
+  ne(value: CheckOperand<T> | T | null): CheckExpression;
+  gt(value: CheckOperand<T> | T): CheckExpression;
+  gte(value: CheckOperand<T> | T): CheckExpression;
+  lt(value: CheckOperand<T> | T): CheckExpression;
+  lte(value: CheckOperand<T> | T): CheckExpression;
+  in(values: readonly T[]): CheckExpression;
+  isNull(): CheckExpression;
+  isNotNull(): CheckExpression;
+}
+export type CheckField<T extends object> = {
+  readonly [K in Extract<keyof T, string>]-?: CheckOperand<T[K]>;
+};
+export type CheckPredicate<T extends object> = (fields: CheckField<T>) => CheckExpression;
+const MAX_CHECK_IN_VALUES = 100;
+class Expr implements CheckExpression {
+  constructor(readonly ast: CheckAst) {
+  }
+  and(other: CheckExpression) {
+    return new Expr({ kind: "and", left: this.ast, right: other.ast });
+  }
+  or(other: CheckExpression) {
+    return new Expr({ kind: "or", left: this.ast, right: other.ast });
+  }
+  not() {
+    return new Expr({ kind: "not", inner: this.ast });
+  }
+}
+class Field implements CheckOperand {
+  constructor(readonly name: string) {
+  }
+  private compare(op: "=" | "<>" | ">" | ">=" | "<" | "<=", value: unknown) {
+    return new Expr({ kind: "compare", op, left: this.name, right: operand(value) });
+  }
+  eq(value: unknown) {
+    return this.compare("=", value);
+  }
+  ne(value: unknown) {
+    return this.compare("<>", value);
+  }
+  gt(value: unknown) {
+    return this.compare(">", value);
+  }
+  gte(value: unknown) {
+    return this.compare(">=", value);
+  }
+  lt(value: unknown) {
+    return this.compare("<", value);
+  }
+  lte(value: unknown) {
+    return this.compare("<=", value);
+  }
+  in(values: readonly unknown[]) {
+    if (!values.length || values.length > MAX_CHECK_IN_VALUES)
+      throw new ModelBuildError(`CHECK IN requires between 1 and ${MAX_CHECK_IN_VALUES} literals.`);
+    return new Expr({ kind: "in", left: this.name, values: values.map(literal) });
+  }
+  isNull() {
+    return new Expr({ kind: "null", left: this.name, not: false });
+  }
+  isNotNull() {
+    return new Expr({ kind: "null", left: this.name, not: true });
+  }
+}
+function operand(value: unknown): string | CheckScalar {
+  return value instanceof Field ? `\u0000${value.name}` : literal(value);
+}
+function literal(value: unknown): CheckScalar {
+  if (value === null || typeof value === "boolean")
+    return value;
+  if (typeof value === "number" && Number.isFinite(value) && Number.isSafeInteger(value))
+    return value;
+  if (typeof value === "string" && value.length <= 1024)
+    return value;
+  throw new ModelBuildError("CHECK literal must be a bounded scalar literal.");
+}
+export function compileCheck<T extends object>(predicate: CheckPredicate<T>): CheckAst {
+  const proxy = new Proxy({}, { get: (_target, name) => typeof name === "string" ? new Field(name) : undefined }) as CheckField<T>;
+  return predicate(proxy).ast;
+}
+/** Projects a property-keyed CHECK AST into a physical identifier domain. */
+export function projectCheckAstIdentifiers(ast: CheckAst, resolve: (propertyName: string) => string): CheckAst {
+  switch (ast.kind) {
+    case "compare": return {
+      ...ast, left: resolve(ast.left), right: typeof ast.right === "string" && ast.right.startsWith("\0") ? `\0${resolve(ast.right.slice(1))}` : ast.right
+    };
+    case "in": return { ...ast, left: resolve(ast.left), values: [...ast.values] };
+    case "null": return { ...ast, left: resolve(ast.left) };
+    case "and":
+    case "or": return {
+      ...ast, left: projectCheckAstIdentifiers(ast.left, resolve), right: projectCheckAstIdentifiers(ast.right, resolve)
+    };
+    case "not": return { ...ast, inner: projectCheckAstIdentifiers(ast.inner, resolve) };
+  }
+}
+/** Validates the complete closed AST against the compiled entity columns before DDL/snapshot rendering. */
+export function validateCheckAst(ast: CheckAst, properties: readonly PropertyModel[]): void {
+  const byName = new Map(properties.map((property) => [property.propertyName, property]));
+  const property = (name: string): PropertyModel => {
+    const value = byName.get(name);
+    if (!value)
+      throw new ModelBuildError(`CHECK references unknown property "${name}".`);
+    return value;
+  };
+  const validateLiteral = (column: PropertyModel, value: CheckScalar): void => {
+    if (value === null)
+      throw new ModelBuildError(`CHECK comparison for "${column.propertyName}" must use isNull()/isNotNull().`);
+    const compatible = (column.type === "integer" || column.type === "real")
+      ? typeof value === "number"
+      : (column.type === "text" || column.type === "datetime")
+        ? typeof value === "string"
+        : column.type === "boolean"
+          ? typeof value === "boolean"
+          : false;
+    if (!compatible)
+      throw new ModelBuildError(`CHECK literal is incompatible with property "${column.propertyName}".`);
+  };
+  const visit = (node: CheckAst): void => {
+    switch (node.kind) {
+      case "and":
+      case "or":
+        visit(node.left);
+        visit(node.right);
+        return;
+      case "not":
+        visit(node.inner);
+        return;
+      case "null":
+        property(node.left);
+        return;
+      case "in": {
+        const left = property(node.left);
+        if (!node.values.length || node.values.length > MAX_CHECK_IN_VALUES)
+          throw new ModelBuildError(`CHECK IN requires between 1 and ${MAX_CHECK_IN_VALUES} literals.`);
+        for (const value of node.values)
+          validateLiteral(left, value);
+        return;
+      }
+      case "compare": {
+        const left = property(node.left);
+        const rightName = typeof node.right === "string" && node.right.startsWith("\0") ? node.right.slice(1) : undefined;
+        if (rightName !== undefined) {
+          const right = property(rightName);
+          if (left.type !== right.type)
+            throw new ModelBuildError(`CHECK column comparison requires identical column types ("${left.propertyName}", "${right.propertyName}").`);
+        }
+        else {
+          validateLiteral(left, node.right as CheckScalar);
+        }
+        if ([">", ">=", "<", "<="].includes(node.op) && !["integer", "real", "text", "datetime"].includes(left.type)) {
+          throw new ModelBuildError(`CHECK ordered comparison is not supported for property "${left.propertyName}".`);
+        }
+      }
+    }
+  };
+  visit(ast);
+}
+export function renderCheck(ast: CheckAst, quote: (name: string) => string): string {
+  switch (ast.kind) {
+    case "compare": return `${quote(ast.left)} ${ast.op} ${typeof ast.right === "string" && ast.right.startsWith("\0") ? quote(ast.right.slice(1)) : sqlLiteral(ast.right as CheckScalar)}`;
+    case "in": return `${quote(ast.left)} IN (${ast.values.map(sqlLiteral).join(", ")})`;
+    case "null": return `${quote(ast.left)} IS ${ast.not ? "NOT " : ""}NULL`;
+    case "and": return `(${renderCheck(ast.left, quote)} AND ${renderCheck(ast.right, quote)})`;
+    case "or": return `(${renderCheck(ast.left, quote)} OR ${renderCheck(ast.right, quote)})`;
+    case "not": return `(NOT ${renderCheck(ast.inner, quote)})`;
+  }
+}
+/** Closed parser for SQL emitted by `renderCheck`; unknown catalog syntax returns undefined. */
+export function parseRenderedCheck(value: string): CheckAst | undefined {
+  const source = stripOuter(value.trim());
+  const logical = splitTopLevel(source, " AND ") ?? splitTopLevel(source, " OR ");
+  if (logical) {
+    const left = parseRenderedCheck(logical.left);
+    const right = parseRenderedCheck(logical.right);
+    return left && right ? { kind: logical.operator === " AND " ? "and" : "or", left, right } : undefined;
+  }
+  const negated = source.match(/^NOT\s+(.+)$/isu);
+  if (negated) {
+    const inner = parseRenderedCheck(negated[1]!);
+    return inner ? { kind: "not", inner } : undefined;
+  }
+  const nullable = source.match(/^(.+?)\s+IS\s+(NOT\s+)?NULL$/isu);
+  if (nullable) {
+    const left = parseIdentifier(nullable[1]!);
+    return left ? { kind: "null", left, not: Boolean(nullable[2]) } : undefined;
+  }
+  const inMatch = source.match(/^(.+?)\s+IN\s*\((.*)\)$/isu);
+  if (inMatch) {
+    const left = parseIdentifier(inMatch[1]!);
+    const values = splitLiterals(inMatch[2]!);
+    return left && values ? { kind: "in", left, values } : undefined;
+  }
+  const comparison = source.match(/^(.+?)\s*(=|<>|>=|<=|>|<)\s*(.+)$/su);
+  if (!comparison)
+    return undefined;
+  const left = parseIdentifier(comparison[1]!);
+  const right = parseOperand(comparison[3]!);
+  return left && right !== undefined ? { kind: "compare", left, op: comparison[2]! as "=" | "<>" | ">" | ">=" | "<" | "<=", right } : undefined;
+}
+function stripOuter(value: string): string {
+  while (value.startsWith("(") && value.endsWith(")") && balancedOuter(value))
+    value = value.slice(1, -1).trim();
+  return value;
+}
+function balancedOuter(value: string): boolean {
+  let depth = 0;
+  let quoted = false;
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i]!;
+    if (char === "'" && value[i - 1] !== "'")
+      quoted = !quoted;
+    if (!quoted) {
+      if (char === "(")
+        depth++;
+      if (char === ")")
+        depth--;
+      if (depth === 0 && i < value.length - 1)
+        return false;
+    }
+  }
+  return depth === 0 && !quoted;
+}
+function splitTopLevel(value: string, separator: " AND " | " OR "): {
+  left: string;
+  right: string;
+  operator: typeof separator;
+} | undefined {
+  let depth = 0;
+  let quoted = false;
+  for (let i = 0; i <= value.length - separator.length; i++) {
+    const char = value[i]!;
+    if (char === "'" && value[i - 1] !== "'")
+      quoted = !quoted;
+    if (!quoted) {
+      if (char === "(")
+        depth++;
+      else if (char === ")")
+        depth--;
+      else if (depth === 0 && value.slice(i, i + separator.length).toUpperCase() === separator)
+        return { left: value.slice(0, i), right: value.slice(i + separator.length), operator: separator };
+    }
+  }
+  return undefined;
+}
+function parseIdentifier(value: string): string | undefined {
+  const identifier = value.trim();
+  const quoted = identifier.match(/^"((?:""|[^"])*)"$/u);
+  return quoted ? quoted[1]!.replaceAll('""', '"') : /^[A-Za-z_][A-Za-z0-9_]*$/u.test(identifier) ? identifier : undefined;
+}
+function parseOperand(value: string): string | CheckScalar | undefined {
+  const raw = value.trim();
+  if (/^(TRUE|FALSE)$/i.test(raw))
+    return /^TRUE$/i.test(raw);
+  const identifier = parseIdentifier(raw);
+  if (identifier)
+    return `\0${identifier}`;
+  return parseLiteral(raw);
+}
+function splitLiterals(value: string): CheckScalar[] | undefined {
+  const parts: string[] = [];
+  let start = 0;
+  let quoted = false;
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] === "'" && value[i - 1] !== "'")
+      quoted = !quoted;
+    if (value[i] === "," && !quoted) {
+      parts.push(value.slice(start, i));
+      start = i + 1;
+    }
+  }
+  if (quoted)
+    return undefined;
+  parts.push(value.slice(start));
+  const parsed = parts.map(parseLiteral);
+  return parsed.some((item) => item === undefined) ? undefined : parsed as CheckScalar[];
+}
+function parseLiteral(value: string): CheckScalar | undefined {
+  const raw = value.trim();
+  if (/^NULL$/i.test(raw))
+    return null;
+  if (/^(TRUE|FALSE)$/i.test(raw))
+    return /^TRUE$/i.test(raw);
+  if (/^-?\d+$/u.test(raw))
+    return Number(raw);
+  const quoted = raw.match(/^'((?:''|[^'])*)'$/su);
+  return quoted ? quoted[1]!.replaceAll("''", "'") : undefined;
+}
+function sqlLiteral(value: CheckScalar): string {
+  if (value === null)
+    return "NULL";
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  if (typeof value === "number")
+    return String(value);
+  return `'${value.replaceAll("'", "''")}'`;
+}

package/library/orm/Schema/ExactSchemaVerifier.ts

@@ -0,0 +1,168 @@
+import type { OrmExpectedSchema } from "./ExpectedSchema";
+import type { IntrospectedSchema, IntrospectedTable } from "./introspection";
+import { createHash } from "node:crypto";
+export type SchemaDifferenceCode = "table.missing" | "column.missing" | "column.unexpected" | "column.type" | "column.nullability" | "column.default" | "column.generation" | "primaryKey.missing" | "primaryKey.unexpected" | "primaryKey.name" | "primaryKey.columns" | "index.missing" | "index.unexpected" | "index.name" | "index.columns" | "index.uniqueness" | "index.method" | "index.unsupportedShape" | "foreignKey.missing" | "foreignKey.unexpected" | "foreignKey.name" | "foreignKey.columns" | "foreignKey.target" | "foreignKey.actions" | "foreignKey.deferrable" | "foreignKey.match" | "check.missing" | "check.unexpected" | "check.name" | "check.expression" | "catalog.unsupported";
+export interface SafeSchemaDescriptor {
+  readonly kind: "absent" | "present" | "canonicalType" | "canonicalDefault" | "canonicalGeneration" | "canonicalExpression" | "orderedColumns" | "referentialActions" | "unsupported";
+  readonly value?: string;
+  readonly values?: readonly string[];
+  readonly hash?: `sha256:${string}`;
+}
+export interface SchemaDifference {
+  readonly code: SchemaDifferenceCode;
+  readonly schema: string;
+  readonly table: string;
+  readonly objectName?: string;
+  readonly expected?: SafeSchemaDescriptor;
+  readonly actual?: SafeSchemaDescriptor;
+}
+export interface SchemaVerificationResult {
+  readonly compatible: boolean;
+  readonly differences: readonly SchemaDifference[];
+}
+const absent: SafeSchemaDescriptor = { kind: "absent" };
+const present: SafeSchemaDescriptor = { kind: "present" };
+const unsupported: SafeSchemaDescriptor = { kind: "unsupported" };
+const value = (kind: SafeSchemaDescriptor["kind"], raw: unknown): SafeSchemaDescriptor => {
+  if (kind === "canonicalDefault" || kind === "canonicalExpression")
+    return {
+      kind, hash: `sha256:${createHash("sha256").update(`bazis.orm.schema-diagnostic/${kind}/v1\0${stable(raw)}`).digest("hex")}`
+    };
+  if (Array.isArray(raw))
+    return { kind, values: raw.map(String) };
+  return { kind, value: String(raw) };
+};
+/** Owner-scoped, deterministic comparison. Ordinary physical column order is deliberately ignored. */
+export class ExactSchemaVerifier {
+  verify(expected: OrmExpectedSchema, actual: IntrospectedSchema, allowMissing = false): SchemaVerificationResult {
+    const differences: SchemaDifference[] = [];
+    const add = (code: SchemaDifferenceCode, schema: string, table: string, objectName?: string, expectedValue?: SafeSchemaDescriptor, actualValue?: SafeSchemaDescriptor) => differences.push({ code, schema, table, objectName, expected: expectedValue, actual: actualValue });
+    for (const table of expected.tables) {
+      const name = `${table.schema}.${table.table}`;
+      const found = actual.tables.get(name);
+      if (!found) {
+        if (!allowMissing)
+          add("table.missing", table.schema, table.table, name, present, absent);
+        continue;
+      }
+      this.table(table, found, table.table, (code, _table, objectName, expectedValue, actualValue) => add(code, table.schema, table.table, objectName, expectedValue, actualValue));
+    }
+    differences.sort((a, b) => Buffer.compare(Buffer.from(`${a.schema}\0${a.table}\0${a.code}\0${a.objectName ?? ""}`, "utf8"), Buffer.from(`${b.schema}\0${b.table}\0${b.code}\0${b.objectName ?? ""}`, "utf8")));
+    return { compatible: differences.length === 0, differences };
+  }
+  private table(expected: OrmExpectedSchema["tables"][number], actual: IntrospectedTable, table: string, add: (code: SchemaDifferenceCode, table: string, objectName?: string, expected?: SafeSchemaDescriptor, actual?: SafeSchemaDescriptor) => void): void {
+    if (actual.unsupported)
+      add("catalog.unsupported", table, table, undefined, unsupported);
+    const columns = new Map(expected.columns.map((column) => [column.column, column]));
+    for (const name of actual.columns.keys())
+      if (!columns.has(name))
+        add("column.unexpected", table, name, absent, present);
+    for (const [name, column] of columns) {
+      const found = actual.columns.get(name);
+      if (!found) {
+        add("column.missing", table, name, present, absent);
+        continue;
+      }
+      if (found.unsupported)
+        add("catalog.unsupported", table, name, undefined, unsupported);
+      if (found.physicalType !== column.physicalType)
+        add("column.type", table, name, value("canonicalType", column.physicalType), value("canonicalType", found.physicalType ?? "unknown"));
+      if (found.notNull === column.nullable)
+        add("column.nullability", table, name, value("present", String(!column.nullable)), value("present", String(found.notNull)));
+      if (stable(found.default) !== stable(column.default))
+        add("column.default", table, name, value("canonicalDefault", column.default), value("canonicalDefault", found.default ?? { kind: "unknown" }));
+      if (found.generation !== column.generation)
+        add("column.generation", table, name, value("canonicalGeneration", column.generation), value("canonicalGeneration", found.generation ?? "unknown"));
+    }
+    if (!actual.primaryKey)
+      add("primaryKey.missing", table, expected.primaryKey.name, present, absent);
+    else {
+      if (actual.primaryKey.name !== expected.primaryKey.name)
+        add("primaryKey.name", table, expected.primaryKey.name, value("present", expected.primaryKey.name), value("present", actual.primaryKey.name));
+      if (!same(actual.primaryKey.columns, expected.primaryKey.columns))
+        add("primaryKey.columns", table, expected.primaryKey.name, value("orderedColumns", expected.primaryKey.columns), value("orderedColumns", actual.primaryKey.columns));
+    }
+    const ordinary = actual.indexes.filter((index) => !index.backingConstraint);
+    const expectedIndexes = new Map(expected.indexes.map((index) => [index.name, index]));
+    for (const index of ordinary) {
+      if (index.unsupported || index.method !== "btree" || index.predicate || index.columns.length === 0)
+        add("index.unsupportedShape", table, index.name, undefined, unsupported);
+      else if (!expectedIndexes.has(index.name))
+        add("index.unexpected", table, index.name, absent, present);
+    }
+    for (const [name, index] of expectedIndexes) {
+      const found = ordinary.find((item) => item.name === name) ?? (ordinary.length === 1 ? ordinary[0] : undefined);
+      if (!found) {
+        add("index.missing", table, name, present, absent);
+        continue;
+      }
+      if (found.name !== name)
+        add("index.name", table, name, value("present", name), value("present", found.name));
+      if (found.unsupported || found.predicate || found.columns.length === 0) {
+        add("catalog.unsupported", table, name, undefined, unsupported);
+        continue;
+      }
+      if (found.unique !== index.unique)
+        add("index.uniqueness", table, name, value("present", String(index.unique)), value("present", String(found.unique)));
+      if (!same(found.columns, index.columns))
+        add("index.columns", table, name, value("orderedColumns", index.columns), value("orderedColumns", found.columns));
+      if (found.method !== "btree")
+        add("index.method", table, name, value("present", "btree"), value("present", found.method ?? "unknown"));
+    }
+    const foreignKeys = actual.foreignKeys ?? [];
+    const expectedForeignKeys = new Map(expected.foreignKeys.map((foreignKey) => [foreignKey.name, foreignKey]));
+    for (const foreignKey of foreignKeys)
+      if (foreignKey.unsupported)
+        add("catalog.unsupported", table, foreignKey.name, undefined, unsupported);
+      else if (foreignKey.deferrable)
+        add("foreignKey.deferrable", table, foreignKey.name, absent, present);
+      else if (!expectedForeignKeys.has(foreignKey.name))
+        add("foreignKey.unexpected", table, foreignKey.name, absent, present);
+    for (const [name, foreignKey] of expectedForeignKeys) {
+      const found = foreignKeys.find((item) => item.name === name) ?? (foreignKeys.length === 1 ? foreignKeys[0] : undefined);
+      if (!found) {
+        add("foreignKey.missing", table, name, present, absent);
+        continue;
+      }
+      const targetSchema = found.targetSchema ?? "public";
+      if (found.name !== name)
+        add("foreignKey.name", table, name, value("present", name), value("present", found.name));
+      if (!same(found.columns, foreignKey.columns))
+        add("foreignKey.columns", table, name, value("orderedColumns", foreignKey.columns), value("orderedColumns", found.columns));
+      if (found.targetTable !== foreignKey.target.table || targetSchema !== foreignKey.target.schema || !same(found.targetColumns, foreignKey.targetColumns))
+        add("foreignKey.target", table, name, value("orderedColumns", [foreignKey.target.schema, foreignKey.target.table, ...foreignKey.targetColumns]), value("orderedColumns", [targetSchema, found.targetTable, ...found.targetColumns]));
+      if (found.onDelete !== foreignKey.onDelete || found.onUpdate !== foreignKey.onUpdate)
+        add("foreignKey.actions", table, name, value("referentialActions", [foreignKey.onDelete, foreignKey.onUpdate]), value("referentialActions", [found.onDelete, found.onUpdate]));
+    }
+    const checks = actual.checks ?? [];
+    const expectedChecks = new Map(expected.checks.map((check) => [check.name, check]));
+    for (const check of checks)
+      if (check.unsupported)
+        add("catalog.unsupported", table, check.name, undefined, unsupported);
+      else if (!expectedChecks.has(check.name))
+        add("check.unexpected", table, check.name, absent, present);
+    for (const [name, check] of expectedChecks) {
+      const found = checks.find((item) => item.name === name) ?? (checks.length === 1 ? checks[0] : undefined);
+      if (!found)
+        add("check.missing", table, name, present, absent);
+      else {
+        if (found.name !== name)
+          add("check.name", table, name, value("present", name), value("present", found.name));
+        if (stable(found.expression) !== stable(check.expression))
+          add("check.expression", table, name, value("canonicalExpression", check.expression), value("canonicalExpression", found.expression));
+      }
+    }
+  }
+}
+function same<T>(a: readonly T[], b: readonly T[]): boolean {
+  return a.length === b.length && a.every((entry, index) => stable(entry) === stable(b[index]));
+}
+function stable(value: unknown): string {
+  if (Array.isArray(value))
+    return `[${value.map(stable).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const object = value as Record<string, unknown>;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stable(object[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}

package/library/orm/Schema/ExpectedSchema.ts

@@ -0,0 +1,43 @@
+import type { EntityModel } from "../Metadata/types";
+import type { OrmModel } from "../Metadata/OrmModel";
+import type { CanonicalDefault, GenerationStrategy } from "./introspection";
+import { projectCheckAstIdentifiers } from "./CheckExpression";
+import { physicalColumnTypes } from "./physicalColumnTypes";
+import { physicalTableIdentity } from "./tableKey";
+
+export interface ExpectedColumn { readonly property: string; readonly column: string; readonly physicalType: string; readonly nullable: boolean; readonly default: CanonicalDefault; readonly generation: GenerationStrategy }
+export interface ExpectedTable { readonly schema: string; readonly table: string; readonly columns: readonly ExpectedColumn[]; readonly primaryKey: { readonly name: string; readonly columns: readonly string[] }; readonly indexes: readonly { readonly name: string; readonly columns: readonly string[]; readonly unique: boolean; readonly method: "btree" }[]; readonly foreignKeys: readonly { readonly name: string; readonly columns: readonly string[]; readonly target: { readonly schema: string; readonly table: string }; readonly targetColumns: readonly string[]; readonly onDelete: string; readonly onUpdate: string }[]; readonly checks: readonly { readonly name: string; readonly expression: unknown }[] }
+export interface OrmExpectedSchema { readonly tables: readonly ExpectedTable[] }
+
+const schemaOf = (model: EntityModel) => physicalTableIdentity(model).schema?.trim() || "public";
+
+/** Pure expected physical contract compiled solely from the explicit entity unit. */
+export function compileExpectedSchema(models: OrmModel): OrmExpectedSchema {
+  const byCtor = new Map(models.entities.map((model) => [model.ctor, model]));
+  const identities = new Set<string>();
+  const types = physicalColumnTypes(models.entities);
+  const tables = models.entities.map((model) => compileTable(model, byCtor, identities, types));
+  return { tables: Object.freeze(tables.sort((a, b) => Buffer.compare(Buffer.from(`${a.schema}\0${a.table}`, "utf8"), Buffer.from(`${b.schema}\0${b.table}`, "utf8")))) };
+}
+
+function compileTable(model: EntityModel, byCtor: ReadonlyMap<EntityModel["ctor"], EntityModel>, identities: Set<string>, types: ReturnType<typeof physicalColumnTypes>): ExpectedTable {
+  const schema = schemaOf(model);
+  const table = physicalTableIdentity(model).table;
+  const identity = `${schema}\0${table}`;
+  if (identities.has(identity)) throw new Error("ORM_SCHEMA_OWNERSHIP_CONFLICT");
+  identities.add(identity);
+  const columns = model.properties.map((property) => ({
+    property: property.propertyName,
+    column: property.columnName,
+    physicalType: types.get(property)!,
+    nullable: !property.required,
+    default: property.databaseDefault,
+    generation: property.generation === "identity" ? "identityByDefault" as const : property.generation === "uuid" ? "uuidDefault" as const : "none" as const,
+  }));
+  const foreignKeys = model.foreignKeys.map((foreignKey) => {
+    const target = byCtor.get(foreignKey.target());
+    if (!target) throw new Error("ORM_SCHEMA_CROSS_UNIT_FOREIGN_KEY");
+    return { name: foreignKey.name ?? `fk_${table}_${foreignKey.properties.join("_")}`, columns: foreignKey.properties.map((name) => model.propertyByName(name)!.columnName), target: { schema: schemaOf(target), table: physicalTableIdentity(target).table }, targetColumns: target.key.map((property) => property.columnName), onDelete: foreignKey.onDelete, onUpdate: foreignKey.onUpdate };
+  });
+  return Object.freeze({ schema, table, columns: Object.freeze(columns), primaryKey: Object.freeze({ name: model.keyName ?? `pk_${table}`, columns: Object.freeze(model.key.map((property) => property.columnName)) }), indexes: Object.freeze(model.indexes.map((index) => Object.freeze({ ...index, columns: Object.freeze([...index.columns]), method: "btree" as const }))), foreignKeys: Object.freeze(foreignKeys), checks: Object.freeze(model.checks.map((check) => Object.freeze({ name: check.name, expression: projectCheckAstIdentifiers(check.expression, (name) => model.propertyByName(name)!.columnName) }))) });
+}