qubu 0.5.0 → 0.6.0

package/dist/constraints-YGyNPQ_z.mjs

@@ -0,0 +1,208 @@
+import { c as dialectMismatchDiagnostic, l as freezeSchemaMetadata, r as isColumnReference } from "./column-r1Y4ivwt.mjs";
+import { p as unsafeSchemaSql } from "./registry-BRcUuazJ.mjs";
+//#region src/schema/indexes.ts
+/**
+* Validate portable and dialect-owned index facts for one target adapter. Unsupported features are
+* reported as data so a serializer can aggregate diagnostics instead of failing during traversal
+* with an opaque exception.
+*/
+function validateIndexDialect(indexMetadata, dialect, path = ["index"]) {
+	const diagnostics = [];
+	const extension = indexMetadata.dialect;
+	if (extension !== void 0) {
+		const mismatch = dialectMismatchDiagnostic(extension, dialect, [...path, "dialect"]);
+		if (mismatch !== void 0) diagnostics.push(mismatch);
+	}
+	if ((dialect === "sqlite" || dialect === "mysql") && indexMetadata.includedColumns !== void 0 && indexMetadata.includedColumns.length > 0) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: `${dialect} indexes do not support included columns`,
+		path: [...path, "includedColumns"],
+		dialect
+	});
+	const mysqlKeyBlockSize = extension?.dialect === "mysql" ? extension.keyBlockSize : void 0;
+	if (mysqlKeyBlockSize !== void 0 && (!Number.isInteger(mysqlKeyBlockSize) || mysqlKeyBlockSize <= 0)) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL index keyBlockSize must be a positive integer",
+		path: [
+			...path,
+			"dialect",
+			"keyBlockSize"
+		],
+		dialect
+	});
+	return Object.freeze(diagnostics);
+}
+/** Declare a portable column or expression index. */
+function index(terms, options) {
+	const resolvedOptions = options ?? {};
+	const candidateKey = resolvedOptions.unique === true && resolvedOptions.where === void 0 && terms.every((term) => {
+		return ("orderKind" in term ? term.expression : term).expressionKind === "column";
+	});
+	return Object.freeze({
+		kind: "index",
+		terms: Object.freeze([...terms]),
+		unique: resolvedOptions.unique === true,
+		predicate: resolvedOptions.where,
+		...resolvedOptions.include !== void 0 ? { includedColumns: Object.freeze([...resolvedOptions.include]) } : {},
+		...resolvedOptions.physicalName !== void 0 ? { physicalName: resolvedOptions.physicalName } : {},
+		...resolvedOptions.dialect !== void 0 ? { dialect: freezeSchemaMetadata(resolvedOptions.dialect) } : {},
+		candidateKey
+	});
+}
+//#endregion
+//#region src/schema/constraints.ts
+/**
+* Validate one constraint against a schema adapter dialect. This is kept separate from construction
+* because the same declaration can be inspected for more than one target dialect before a
+* serializer is selected.
+*/
+function validateConstraintDialect(constraint, dialect, path = ["constraint"]) {
+	const diagnostics = [];
+	const extension = constraint.dialect;
+	if (extension !== void 0) {
+		const mismatch = dialectMismatchDiagnostic(extension, dialect, [...path, "dialect"]);
+		if (mismatch !== void 0) diagnostics.push(mismatch);
+		if (extension.dialect === "postgresql" && "notValid" in extension && extension.notValid === true && (constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint")) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL NOT VALID is not supported for key constraints",
+			path: [
+				...path,
+				"dialect",
+				"notValid"
+			],
+			dialect
+		});
+		if (extension.dialect === "sqlite" && "onConflict" in extension && extension.onConflict !== void 0 && constraint.kind === "foreign-key") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "SQLite conflict policies do not apply to foreign keys",
+			path: [
+				...path,
+				"dialect",
+				"onConflict"
+			],
+			dialect
+		});
+	}
+	if (constraint.kind === "foreign-key" && constraint.match === "partial" && dialect === "mysql") diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL does not support MATCH PARTIAL foreign keys",
+		path: [...path, "match"],
+		dialect
+	});
+	if (constraint.kind === "foreign-key" && constraint.deferrable === true && dialect === "mysql") diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL foreign keys cannot be declared DEFERRABLE",
+		path: [...path, "deferrable"],
+		dialect
+	});
+	if (constraint.initially !== void 0 && constraint.deferrable !== true) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "An initial constraint timing requires deferrable: true",
+		path: [...path, "initially"],
+		dialect
+	});
+	return Object.freeze(diagnostics);
+}
+function primaryKey(...columnsAndOptions) {
+	const last = columnsAndOptions.at(-1);
+	const options = last && typeof last === "object" && !("expressionKind" in last) ? last : void 0;
+	return freezeConstraint("primary-key", options ? columnsAndOptions.slice(0, -1) : columnsAndOptions, options);
+}
+function unique(...columnsAndOptions) {
+	const last = columnsAndOptions.at(-1);
+	const options = last && typeof last === "object" && !("expressionKind" in last) ? last : void 0;
+	return freezeConstraint("unique", options ? columnsAndOptions.slice(0, -1) : columnsAndOptions, options);
+}
+function uniqueConstraint(...columnsAndOptions) {
+	const last = columnsAndOptions.at(-1);
+	const options = last && typeof last === "object" && !("expressionKind" in last) ? last : void 0;
+	const columns = options ? columnsAndOptions.slice(0, -1) : columnsAndOptions;
+	const resolvedOptions = options ?? {};
+	return freezeConstraint("unique-constraint", columns, resolvedOptions, resolvedOptions.nulls ?? "distinct");
+}
+/** Pair a table with the exact columns targeted by a foreign key. */
+function references(table, ...columns) {
+	return Object.freeze({
+		table,
+		columns: Object.freeze([...columns])
+	});
+}
+/** Declare a single-column or composite foreign key. */
+function foreignKey(columns, target, options) {
+	return freezeConstraint("foreign-key", columns, options, target);
+}
+/**
+* Reconstruct a foreign key proved by database catalog metadata.
+*
+* @remarks
+*   Use this helper for generated or introspection-owned declarations when one or both native SQL
+*   domains are unresolved. It accepts unresolved domains, but still rejects known domain
+*   mismatches, unequal tuple arity, and local columns from different sources. The enclosing
+*   `table()` declaration continues to verify target-column ownership and candidate-key metadata.
+*   Resolved targets also receive runtime shape, ownership, and arity checks. The returned value
+*   serializes as an ordinary foreign-key constraint.
+*/
+function catalogForeignKey(columns, target, options) {
+	assertCatalogForeignKeyColumns(columns, "local");
+	return freezeConstraint("foreign-key", columns, options, validateCatalogForeignKeyTargetInput(target, columns.length));
+}
+/** Declare a boolean table invariant. */
+function check(expression, options) {
+	return freezeConstraint("check", void 0, options, expression);
+}
+/**
+* Reconstruct a boolean check from opaque SQL recovered from a database catalog.
+*
+* @remarks
+*   This helper records catalog origin as a narrow type-level proof. It gives the opaque expression
+*   the {@link SqlBoolean} semantic type without changing the ordinary {@link check} contract. Qubu
+*   does not parse or infer dependencies from the SQL. It preserves the text apart from normalizing
+*   line endings and retains the dialect tag in serialized schema metadata.
+*/
+function catalogCheck(input, options) {
+	assertCatalogCheckSql(input);
+	return freezeConstraint("check", void 0, options, unsafeSchemaSql(input.dialect, input.sql));
+}
+function assertCatalogCheckSql(value) {
+	if (typeof value !== "object" || value === null) throw new TypeError("catalogCheck() requires dialect-tagged SQL data");
+	const input = value;
+	if (input.dialect !== "postgresql" && input.dialect !== "sqlite" && input.dialect !== "mysql") throw new TypeError(`catalogCheck() requires a supported catalog dialect, received "${String(input.dialect)}"`);
+	if (typeof input.sql !== "string" || input.sql.trim().length === 0) throw new TypeError("catalogCheck() requires non-empty SQL text");
+}
+function assertCatalogForeignKeyColumns(value, side) {
+	if (!Array.isArray(value) || value.length === 0) throw new TypeError(`catalogForeignKey() requires at least one ${side} column`);
+	if (!value.every(isColumnReference)) throw new TypeError(`catalogForeignKey() requires ${side} columns to be column references`);
+}
+function validateCatalogForeignKeyTargetInput(value, localArity) {
+	return typeof value === "function" ? () => validateCatalogForeignKeyTarget(value(), localArity) : validateCatalogForeignKeyTarget(value, localArity);
+}
+function validateCatalogForeignKeyTarget(value, localArity) {
+	if (typeof value !== "object" || value === null) throw new TypeError("catalogForeignKey() requires a foreign-key target");
+	const target = value;
+	assertCatalogForeignKeyColumns(target.columns, "target");
+	if (target.columns.length !== localArity) throw new TypeError(`catalogForeignKey() column arity differs: ${localArity} local and ${target.columns.length} target`);
+	const table = target.table;
+	if (typeof table !== "object" || table === null || typeof table.columns !== "object" || table.columns === null) throw new TypeError("catalogForeignKey() target must reference a table");
+	for (const column of target.columns) if (table.columns[column.fieldName] !== column) throw new TypeError(`catalogForeignKey() target column "${column.fieldName}" does not belong to its table`);
+	return target;
+}
+function freezeConstraint(kind, columns, options, extra) {
+	const value = { kind };
+	const optionValues = options;
+	if (columns !== void 0) value.columns = Object.freeze([...columns]);
+	if (kind === "check") value.expression = extra;
+	else if (kind === "foreign-key") value.target = extra;
+	else if (kind === "unique-constraint") value.nulls = extra;
+	if (optionValues?.physicalName !== void 0) value.physicalName = optionValues.physicalName;
+	if (optionValues?.dialect !== void 0) value.dialect = freezeSchemaMetadata(optionValues.dialect);
+	if (optionValues?.deferrable !== void 0) value.deferrable = optionValues.deferrable;
+	if (optionValues?.initially !== void 0) value.initially = optionValues.initially;
+	if (kind === "foreign-key") {
+		if (optionValues?.onUpdate !== void 0) value.onUpdate = optionValues.onUpdate;
+		if (optionValues?.onDelete !== void 0) value.onDelete = optionValues.onDelete;
+		if (optionValues?.match !== void 0) value.match = optionValues.match;
+	}
+	return Object.freeze(value);
+}
+//#endregion
+export { primaryKey as a, uniqueConstraint as c, validateIndexDialect as d, foreignKey as i, validateConstraintDialect as l, catalogForeignKey as n, references as o, check as r, unique as s, catalogCheck as t, index as u };

package/dist/core.mjs

@@ -1,7 +1,7 @@
 import { a as assertDialectCapability, o as createDialect, s as resolveCastTarget } from "./json-Db7XRD91.mjs";
-import { a as routineName, c as render, i as typedCall, s as typedCast, t as createClause } from "./types-CTENnDh9.mjs";
-import { B as isExpression, H as makeExpression, J as isFragment, K as withDialectCapability, W as markExpressionCategory, X as sequence, Y as parenthesize, a as qualifiedIdentifier, i as identifier, n as expressionFragment, q as fragment } from "./column-DmazTL67.mjs";
-import { a as parameter, r as typedValue } from "./value-BEEj_Ayd.mjs";
+import { a as routineName, c as render, i as typedCall, s as typedCast, t as createClause } from "./types-BIJsj2fJ.mjs";
+import { C as fragment, E as sequence, S as withDialectCapability, T as parenthesize, a as qualifiedIdentifier, b as markExpressionCategory, g as isExpression, i as identifier, n as expressionFragment, v as makeExpression, w as isFragment } from "./column-r1Y4ivwt.mjs";
+import { a as parameter, r as typedValue } from "./value-D14I_XgL.mjs";
 //#region src/core/primitives/compose.ts
 function commaSeparated(parts) {
 	return sequence(parts, ", ");

package/dist/index-B2rZf3-2.d.mts

@@ -0,0 +1,32 @@
+import { f as SnapshotDiagnostic } from "./types-C0VkiwpR.mjs";
+import { n as CompleteSchemaSnapshotInput, t as CompleteSchemaSnapshot, u as CompleteSnapshotDecodeResult } from "./complete-types-CY0KbzNw.mjs";
+//#region src/snapshot/complete.d.ts
+/** Error raised by throwing APIs after collecting strict v2 diagnostics. */
+declare class CompleteSnapshotValidationError extends TypeError {
+  readonly name = "CompleteSnapshotValidationError";
+  readonly diagnostics: readonly SnapshotDiagnostic[];
+  readonly issues: readonly SnapshotDiagnostic[];
+  constructor(diagnostics: readonly SnapshotDiagnostic[]);
+}
+/** Decode and strictly validate a complete Snapshot v2 JSON value. */
+declare function decodeCompleteSchemaSnapshot(input: string | unknown): CompleteSnapshotDecodeResult;
+/** Validate a complete snapshot and throw one structured error on failure. */
+declare function assertCompleteSchemaSnapshot(input: CompleteSchemaSnapshotInput | string): CompleteSchemaSnapshot;
+/** Return a fixed-order, deeply immutable complete snapshot. */
+declare function canonicalizeCompleteSchemaSnapshot(input: CompleteSchemaSnapshotInput): CompleteSchemaSnapshot;
+/** Encode a complete snapshot with deterministic property and array order. */
+declare function encodeCompleteSchemaSnapshot(snapshot: CompleteSchemaSnapshot): string;
+/** Compute the deterministic content fingerprint for a complete Snapshot v2. */
+declare function completeSchemaSnapshotFingerprint(snapshot: CompleteSchemaSnapshotInput | string): string;
+/** Numbered aliases for tooling that keeps v1 and v2 side by side. */
+declare const decodeSchemaSnapshotV2: typeof decodeCompleteSchemaSnapshot;
+declare const assertSchemaSnapshotV2: typeof assertCompleteSchemaSnapshot;
+declare const encodeSchemaSnapshotV2: typeof encodeCompleteSchemaSnapshot;
+declare const canonicalizeSchemaSnapshotV2: typeof canonicalizeCompleteSchemaSnapshot;
+declare const schemaSnapshotV2Fingerprint: typeof completeSchemaSnapshotFingerprint;
+declare const decodeCompleteSnapshot: typeof decodeCompleteSchemaSnapshot;
+declare const assertCompleteSnapshot: typeof assertCompleteSchemaSnapshot;
+declare const encodeCompleteSnapshot: typeof encodeCompleteSchemaSnapshot;
+declare const fingerprintCompleteSchemaSnapshot: typeof completeSchemaSnapshotFingerprint;
+//#endregion
+export { canonicalizeCompleteSchemaSnapshot as a, decodeCompleteSchemaSnapshot as c, encodeCompleteSchemaSnapshot as d, encodeCompleteSnapshot as f, schemaSnapshotV2Fingerprint as h, assertSchemaSnapshotV2 as i, decodeCompleteSnapshot as l, fingerprintCompleteSchemaSnapshot as m, assertCompleteSchemaSnapshot as n, canonicalizeSchemaSnapshotV2 as o, encodeSchemaSnapshotV2 as p, assertCompleteSnapshot as r, completeSchemaSnapshotFingerprint as s, CompleteSnapshotValidationError as t, decodeSchemaSnapshotV2 as u };

package/dist/index.mjs

@@ -1,13 +1,15 @@
 import { a as assertDialectCapability } from "./json-Db7XRD91.mjs";
-import { c as render, n as call, o as cast, r as schemaCall, t as createClause } from "./types-CTENnDh9.mjs";
+import { c as render, n as call, o as cast, r as schemaCall, t as createClause } from "./types-BIJsj2fJ.mjs";
 import { n as queryValidationError, t as QueryValidationError } from "./errors-Dxv73YJu.mjs";
-import { $ as createResultShape, B as isExpression, D as generatedColumn, E as externalGeneratedColumn, G as markSchemaExpression, H as makeExpression, J as isFragment, O as identityColumn, Q as booleanResultDecoder, R as resolveSqlNames, S as uuid, T as externalDefault, U as makeSchemaExpression, V as isSchemaExpression, W as markExpressionCategory, Y as parenthesize, Z as ResultDecodingError, _ as nullable, at as resultValueOf, b as text, c as boolean, d as date, et as dateResultDecoder, f as encodeColumnParameter, g as nativeStorage, h as nativeColumn, i as identifier, it as resultValue, l as column, m as json, nt as jsonTextResultDecoder, o as bigint, ot as timestampResultDecoder, p as integer, q as fragment, rt as resultShapeValue, s as binary, t as createColumnReference, tt as decodeResultRow, v as numeric, x as timestamp, y as portableStorage, z as snakeCaseIdentifier } from "./column-DmazTL67.mjs";
-import { i as value, t as asValue } from "./value-BEEj_Ayd.mjs";
-import { a as isDistinctFrom, c as lt, d as notLike, f as expressionOperand, i as gte, l as lte, m as renderOperands, n as eq, o as isNotDistinctFrom, p as isNullOperand, r as gt, s as like, u as ne } from "./relational-x3BDVX9e.mjs";
+import { A as dateResultDecoder, C as fragment, D as ResultDecodingError, F as resultValueOf, I as timestampResultDecoder, M as jsonTextResultDecoder, N as resultShapeValue, O as booleanResultDecoder, P as resultValue, T as parenthesize, _ as isSchemaExpression, b as markExpressionCategory, g as isExpression, h as snakeCaseIdentifier, i as identifier, j as decodeResultRow, k as createResultShape, m as resolveSqlNames, t as createColumnReference, v as makeExpression, w as isFragment, x as markSchemaExpression, y as makeSchemaExpression } from "./column-r1Y4ivwt.mjs";
+import { C as identityColumn, S as generatedColumn, _ as uuid, b as externalDefault, c as integer, d as nativeStorage, f as nullable, g as timestamp, h as text, i as column, l as json, m as portableStorage, n as binary, o as date, p as numeric, r as boolean, s as encodeColumnParameter, t as bigint, u as nativeColumn, x as externalGeneratedColumn } from "./column-Da37jYSD.mjs";
+import { i as value, t as asValue } from "./value-D14I_XgL.mjs";
+import { a as isDistinctFrom, c as lt, d as notLike, f as expressionOperand, i as gte, l as lte, m as renderOperands, n as eq, o as isNotDistinctFrom, p as isNullOperand, r as gt, s as like, u as ne } from "./relational-CxnLCqZQ.mjs";
 import { t as omit } from "./omit-OxV58AwX.mjs";
-import { r as exposeColumns, t as createSource } from "./source-C4Vmu5bb.mjs";
-import { n as alias, r as lateral, t as table } from "./table-DLQ7YWth.mjs";
-import { C as index, S as unsafeSchemaSql, c as check, d as references, f as unique, i as schema, l as foreignKey, o as catalogCheck, p as uniqueConstraint, s as catalogForeignKey, u as primaryKey } from "./registry-BGqa05et.mjs";
+import { r as exposeColumns, t as createSource } from "./source-SqrKWjFJ.mjs";
+import { n as alias, r as lateral, t as table } from "./table-BwflqeAj.mjs";
+import { a as primaryKey, c as uniqueConstraint, i as foreignKey, n as catalogForeignKey, o as references, r as check, s as unique, t as catalogCheck, u as index } from "./constraints-YGyNPQ_z.mjs";
+import { i as schema, p as unsafeSchemaSql } from "./registry-BRcUuazJ.mjs";
 //#region src/execution.ts
 function qubu(adapter, options = {}) {
 	const observation = createObservation(options.hooks);

package/dist/introspection.mjs

@@ -1,5 +1,5 @@
 import { a as toSnapshotJsonValue } from "./canonical-DMvR9yBe.mjs";
-import { a as hasIntrospectionErrors, i as createIntrospectionDiagnostic, n as introspectedPhysicalIdentityPolicy, r as IntrospectionError, t as mapCatalogToSnapshot } from "./snapshot-BSraiLtH.mjs";
+import { a as hasIntrospectionErrors, i as createIntrospectionDiagnostic, n as introspectedPhysicalIdentityPolicy, r as IntrospectionError, t as mapCatalogToSnapshot } from "./snapshot-Xam8-q0j.mjs";
 import { n as assertCompleteSchemaSnapshot } from "./complete-DP7pliuY.mjs";
 import "./snapshot.mjs";
 //#region src/introspection/catalog.ts

package/dist/{on-conflict-jPsl9l0K.mjs → on-conflict-DZQ85f1t.mjs}

@@ -1,8 +1,9 @@
 import { a as assertDialectCapability } from "./json-Db7XRD91.mjs";
 import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
-import { B as isExpression, f as encodeColumnParameter, i as identifier, q as fragment, t as createColumnReference, u as columnResultValue } from "./column-DmazTL67.mjs";
+import { C as fragment, g as isExpression, i as identifier, t as createColumnReference } from "./column-r1Y4ivwt.mjs";
+import { a as columnResultValue, s as encodeColumnParameter } from "./column-Da37jYSD.mjs";
 import { t as omit } from "./omit-OxV58AwX.mjs";
-import { r as exposeColumns, t as createSource } from "./source-C4Vmu5bb.mjs";
+import { r as exposeColumns, t as createSource } from "./source-SqrKWjFJ.mjs";
 //#region src/query/mutation/on-conflict.ts
 /** Columns from the proposed INSERT row, available inside DO UPDATE. */
 function excluded(table) {

package/dist/postgres.mjs

@@ -1,8 +1,8 @@
 import { n as postgresJson, o as createDialect } from "./json-Db7XRD91.mjs";
-import { K as withDialectCapability } from "./column-DmazTL67.mjs";
-import { t as comparison } from "./relational-x3BDVX9e.mjs";
+import { S as withDialectCapability } from "./column-r1Y4ivwt.mjs";
+import { t as comparison } from "./relational-CxnLCqZQ.mjs";
 import { n as postgresExplain } from "./explain-CkIK13L_.mjs";
-import { i as onConflict, n as doUpdate, r as excluded, t as doNothing } from "./on-conflict-jPsl9l0K.mjs";
+import { i as onConflict, n as doUpdate, r as excluded, t as doNothing } from "./on-conflict-DZQ85f1t.mjs";
 //#region src/dialects/postgres.ts
 const postgresRowLockModeSql = {
 	update: "UPDATE",

package/dist/registry-BRcUuazJ.mjs

@@ -0,0 +1,256 @@
+import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
+import { _ as isSchemaExpression, h as snakeCaseIdentifier, r as isColumnReference, x as markSchemaExpression, y as makeSchemaExpression } from "./column-r1Y4ivwt.mjs";
+import { n as isValueExpression } from "./value-D14I_XgL.mjs";
+//#region src/schema/expressions.ts
+/** Error raised before a schema expression can become persisted SQL. */
+var SchemaExpressionError = class extends TypeError {
+	code;
+	mode;
+	constructor(code, message, mode) {
+		super(message);
+		this.name = "SchemaExpressionError";
+		this.code = code;
+		this.mode = mode;
+	}
+};
+/**
+* Normalize only line endings. Whitespace, quoting, and every other byte of a raw schema expression
+* remain under the extension author's control.
+*/
+function normalizeSchemaSql(sql) {
+	return sql.replace(/\r\n?/g, "\n");
+}
+function schemaExpression(expression) {
+	return markSchemaExpression(expression);
+}
+/**
+* Define an extension with the restricted schema context. This is the typed alternative to
+* {@link unsafeSchemaSql} for deterministic custom syntax.
+*/
+function defineSchemaExpression(kind, render) {
+	return makeSchemaExpression(kind, (context) => render(context));
+}
+function unsafeSchemaSql(dialectOrOptions, sql) {
+	const dialect = typeof dialectOrOptions === "string" ? dialectOrOptions : dialectOrOptions.dialect;
+	const source = typeof dialectOrOptions === "string" ? sql : dialectOrOptions.sql;
+	if (!dialect) throw new TypeError("unsafeSchemaSql() requires a dialect tag");
+	if (source === void 0) throw new TypeError("unsafeSchemaSql() requires SQL text");
+	const normalized = normalizeSchemaSql(source);
+	const expression = makeSchemaExpression("unsafe", (context) => context.append(normalized));
+	return Object.freeze({
+		...expression,
+		schemaSqlDialect: dialect,
+		schemaSql: normalized
+	});
+}
+/** Identify a dialect-tagged raw schema expression. */
+function isUnsafeSchemaSql(value) {
+	return isSchemaExpression(value) && value.expressionKind === "unsafe" && typeof value.schemaSqlDialect === "string" && typeof value.schemaSql === "string";
+}
+function renderSchemaExpression(expression, optionsOrMode, dialectOption) {
+	const options = typeof optionsOrMode === "string" ? {
+		mode: optionsOrMode,
+		dialect: dialectOption
+	} : optionsOrMode;
+	const dialect = options.dialect ?? standardDialect();
+	if (!isSchemaExpression(expression)) throw new SchemaExpressionError("not-deterministic", "Only branded deterministic expressions can be rendered as schema SQL", options.mode);
+	assertSupportedExpression(expression, options.mode);
+	let text = "";
+	const context = {
+		dialect,
+		projectionMode: "result",
+		schemaMode: options.mode,
+		append(value) {
+			text += value;
+		},
+		parameter() {
+			throw new SchemaExpressionError("parameter", "Schema expressions cannot render query parameters", options.mode);
+		},
+		literal(value) {
+			text += renderSchemaLiteral(dialect, value, options.mode);
+		},
+		renderColumnReference(columnName) {
+			if (options.mode === "default") throw new SchemaExpressionError("column-not-allowed", "Default expressions cannot reference table columns", options.mode);
+			text += dialect.quoteIdentifier(columnName);
+		},
+		render(part) {
+			renderSchemaPart(context, part, options.mode);
+		},
+		renderRelation() {
+			throw new SchemaExpressionError("unsupported-expression", "Schema expressions cannot contain subqueries", options.mode);
+		}
+	};
+	renderSchemaPart(context, expression, options.mode);
+	return Object.freeze({
+		text,
+		parameters: Object.freeze([])
+	});
+}
+/** Convenience form for callers that only need the SQL text. */
+function renderSchemaSql(expression, options) {
+	return renderSchemaExpression(expression, options).text;
+}
+function renderSchemaPart(context, part, mode) {
+	if (isValueExpression(part)) {
+		context.literal(part.value);
+		return;
+	}
+	if (isColumnReference(part)) {
+		context.renderColumnReference(part.columnName);
+		return;
+	}
+	if (isUnsafeSchemaSql(part)) {
+		if (part.schemaSqlDialect !== context.dialect.name) throw new SchemaExpressionError("dialect-mismatch", `Schema SQL is tagged for "${part.schemaSqlDialect}" but rendered for "${context.dialect.name}"`, mode);
+		context.append(part.schemaSql);
+		return;
+	}
+	if (!isSchemaExpression(part)) throw new SchemaExpressionError("not-deterministic", "Schema expressions may only compose branded expressions, columns, and literals", mode);
+	assertSupportedExpression(part, mode);
+	part.render(context);
+}
+function assertSupportedExpression(expression, mode) {
+	if (expression.expressionKind === "subquery" || expression.expressionCategory) throw new SchemaExpressionError("unsupported-expression", "Aggregates, windows, and subqueries are not valid schema expressions", mode);
+}
+function renderSchemaLiteral(dialect, value, mode) {
+	if (dialect.renderSchemaLiteral) {
+		const rendered = dialect.renderSchemaLiteral(value);
+		if (typeof rendered !== "string" || rendered.includes("?")) throw new SchemaExpressionError("invalid-literal", "A schema literal renderer must return parameter-free SQL text", mode);
+		return rendered;
+	}
+	if (value === null) return "NULL";
+	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
+	if (typeof value === "bigint") return String(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new SchemaExpressionError("unsupported-value", "Schema literals require finite numbers", mode);
+		return Object.is(value, -0) ? "0" : String(value);
+	}
+	throw new SchemaExpressionError("unsupported-value", `Unsupported schema literal type: ${value === void 0 ? "undefined" : typeof value}`, mode);
+}
+//#endregion
+//#region src/schema/registry.ts
+/** The first naming-policy version used by schema metadata. */
+const schemaNamingPolicyVersion = 1;
+/**
+* The built-in naming policy for schema-generated physical names.
+*
+* Explicit names supplied to `table()` remain unchanged. The policy is used by tooling when it
+* needs a physical name for a logical table ID.
+*/
+const defaultSchemaNamingPolicy = Object.freeze({
+	version: 1,
+	tableName: snakeCaseIdentifier
+});
+/** Error thrown when a root schema fails registry or naming validation. */
+var SchemaValidationError = class extends Error {
+	name = "SchemaValidationError";
+	diagnostics;
+	/** Alias matching validation libraries that call findings "issues". */
+	issues;
+	constructor(diagnostics) {
+		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => Object.freeze({
+			...diagnostic,
+			path: Object.freeze([...diagnostic.path]),
+			relatedPaths: diagnostic.relatedPaths ? Object.freeze(diagnostic.relatedPaths.map((path) => Object.freeze([...path]))) : void 0
+		})));
+		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+		this.diagnostics = frozenDiagnostics;
+		this.issues = frozenDiagnostics;
+	}
+};
+function entriesOf(input) {
+	if (Array.isArray(input)) return input;
+	return Object.entries(input);
+}
+function validLogicalId(id) {
+	return id.length > 0 && id === id.trim() && !/[.\\/\u0000-\u001f\u007f]/u.test(id);
+}
+function validNamespace(namespace) {
+	return namespace.length > 0 && namespace === namespace.trim() && !/[.\\/\u0000-\u001f\u007f"']/u.test(namespace);
+}
+function validateEntries(entries, namespace, namingPolicy) {
+	const diagnostics = [];
+	const ids = /* @__PURE__ */ new Map();
+	const physicalNames = /* @__PURE__ */ new Map();
+	const generatedNames = /* @__PURE__ */ new Map();
+	for (const [index, [id, table]] of entries.entries()) {
+		const path = ["tables", id];
+		const previousId = ids.get(id);
+		if (previousId !== void 0) diagnostics.push({
+			code: "duplicate-table-id",
+			message: `Table ID "${id}" is declared more than once`,
+			path,
+			relatedPaths: [["tables", entries[previousId][0]]]
+		});
+		else ids.set(id, index);
+		if (!validLogicalId(id)) diagnostics.push({
+			code: "invalid-table-id",
+			message: `Table ID "${id}" must be a non-empty logical identifier`,
+			path
+		});
+		const physicalName = table.tableName || namingPolicy.tableName(id);
+		const previousPhysicalName = physicalNames.get(physicalName);
+		if (previousPhysicalName !== void 0) diagnostics.push({
+			code: "duplicate-physical-name",
+			message: `Tables "${entries[previousPhysicalName][0]}" and "${id}" both use physical name "${physicalName}"`,
+			path: [...path, "physicalName"],
+			relatedPaths: [[
+				"tables",
+				entries[previousPhysicalName][0],
+				"physicalName"
+			]]
+		});
+		else physicalNames.set(physicalName, index);
+		const generatedName = namingPolicy.tableName(id);
+		const previousGeneratedName = generatedNames.get(generatedName);
+		if (previousGeneratedName !== void 0) diagnostics.push({
+			code: "generated-name-collision",
+			message: `Logical table IDs "${entries[previousGeneratedName][0]}" and "${id}" generate the same physical name "${generatedName}"`,
+			path: [...path, "generatedName"],
+			relatedPaths: [[
+				"tables",
+				entries[previousGeneratedName][0],
+				"generatedName"
+			]]
+		});
+		else generatedNames.set(generatedName, index);
+	}
+	if (namespace !== void 0 && !validNamespace(namespace)) diagnostics.push({
+		code: "invalid-namespace",
+		message: `Schema namespace "${namespace}" must be a non-empty identifier without qualification or control characters`,
+		path: ["namespace"]
+	});
+	return Object.freeze(diagnostics);
+}
+function freezeTableNames(entries, namingPolicy) {
+	return Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, table.tableName || namingPolicy.tableName(id)])));
+}
+function createSchema(entries, tables, options = {}) {
+	const namingPolicy = options.namingPolicy ?? defaultSchemaNamingPolicy;
+	const diagnostics = validateEntries(entries, options.namespace, namingPolicy);
+	if (diagnostics.length > 0) throw new SchemaValidationError(diagnostics);
+	const tableNames = freezeTableNames(entries, namingPolicy);
+	const registry = Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, Object.freeze({
+		id,
+		table,
+		physicalName: tableNames[id]
+	})])));
+	return Object.freeze({
+		schemaKind: "schema",
+		tables: Object.freeze({ ...tables }),
+		registry,
+		tableNames,
+		namespace: options.namespace,
+		namingPolicy: Object.freeze({ ...namingPolicy })
+	});
+}
+function schema(tables, options) {
+	const entries = entriesOf(tables);
+	return createSchema(entries, Object.fromEntries(entries), options);
+}
+/** Generate a v1 physical name for a logical table ID. */
+function generatedTableName(logicalId, namingPolicy = defaultSchemaNamingPolicy) {
+	return namingPolicy.tableName(logicalId);
+}
+//#endregion
+export { schemaNamingPolicyVersion as a, isUnsafeSchemaSql as c, renderSchemaSql as d, schemaExpression as f, schema as i, normalizeSchemaSql as l, defaultSchemaNamingPolicy as n, SchemaExpressionError as o, unsafeSchemaSql as p, generatedTableName as r, defineSchemaExpression as s, SchemaValidationError as t, renderSchemaExpression as u };

package/dist/{relational-x3BDVX9e.mjs → relational-CxnLCqZQ.mjs}

@@ -1,6 +1,6 @@
 import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
-import { U as makeSchemaExpression, it as resultValue } from "./column-DmazTL67.mjs";
-import { n as isValueExpression, t as asValue } from "./value-BEEj_Ayd.mjs";
+import { P as resultValue, y as makeSchemaExpression } from "./column-r1Y4ivwt.mjs";
+import { n as isValueExpression, t as asValue } from "./value-D14I_XgL.mjs";
 //#region src/expressions/operators/shared.ts
 function isNullOperand(value) {
 	return value === null || isValueExpression(value) && value.value === null;

package/dist/schema.mjs

@@ -1,6 +1,8 @@
-import { A as SchemaMetadataValidationError, C as ColumnBehaviorError, D as generatedColumn, E as externalGeneratedColumn, F as isValidSchemaObjectName, I as materializeSchemaObjectIdentity, L as materializeSchemaObjectRecord, M as dialectMismatchDiagnostic, N as freezeSchemaMetadata, O as identityColumn, P as generatedSchemaObjectName, S as uuid, T as externalDefault, _ as nullable, b as text, c as boolean, d as date, f as encodeColumnParameter, g as nativeStorage, h as nativeColumn, j as assertSchemaDialectSupport, k as resolveColumnBehavior, l as column, m as json, o as bigint, p as integer, s as binary, u as columnResultValue, v as numeric, w as canonicalLiteral, x as timestamp, y as portableStorage } from "./column-DmazTL67.mjs";
-import { i as sourceIdentity, n as customSource, r as exposeColumns, t as createSource } from "./source-C4Vmu5bb.mjs";
-import { n as alias, r as lateral, t as table } from "./table-DLQ7YWth.mjs";
-import { C as index, S as unsafeSchemaSql, _ as isUnsafeSchemaSql, a as schemaNamingPolicyVersion, b as renderSchemaSql, c as check, d as references, f as unique, g as defineSchemaExpression, h as SchemaExpressionError, i as schema, l as foreignKey, m as validateConstraintDialect, n as defaultSchemaNamingPolicy, o as catalogCheck, p as uniqueConstraint, r as generatedTableName, s as catalogForeignKey, t as SchemaValidationError, u as primaryKey, v as normalizeSchemaSql, w as validateIndexDialect, x as schemaExpression, y as renderSchemaExpression } from "./registry-BGqa05et.mjs";
+import { c as dialectMismatchDiagnostic, d as isValidSchemaObjectName, f as materializeSchemaObjectIdentity, l as freezeSchemaMetadata, o as SchemaMetadataValidationError, p as materializeSchemaObjectRecord, s as assertSchemaDialectSupport, u as generatedSchemaObjectName } from "./column-r1Y4ivwt.mjs";
+import { C as identityColumn, S as generatedColumn, _ as uuid, a as columnResultValue, b as externalDefault, c as integer, d as nativeStorage, f as nullable, g as timestamp, h as text, i as column, l as json, m as portableStorage, n as binary, o as date, p as numeric, r as boolean, s as encodeColumnParameter, t as bigint, u as nativeColumn, v as ColumnBehaviorError, w as resolveColumnBehavior, x as externalGeneratedColumn, y as canonicalLiteral } from "./column-Da37jYSD.mjs";
+import { i as sourceIdentity, n as customSource, r as exposeColumns, t as createSource } from "./source-SqrKWjFJ.mjs";
+import { n as alias, r as lateral, t as table } from "./table-BwflqeAj.mjs";
+import { a as primaryKey, c as uniqueConstraint, d as validateIndexDialect, i as foreignKey, l as validateConstraintDialect, n as catalogForeignKey, o as references, r as check, s as unique, t as catalogCheck, u as index } from "./constraints-YGyNPQ_z.mjs";
+import { a as schemaNamingPolicyVersion, c as isUnsafeSchemaSql, d as renderSchemaSql, f as schemaExpression, i as schema, l as normalizeSchemaSql, n as defaultSchemaNamingPolicy, o as SchemaExpressionError, p as unsafeSchemaSql, r as generatedTableName, s as defineSchemaExpression, t as SchemaValidationError, u as renderSchemaExpression } from "./registry-BRcUuazJ.mjs";
 import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
 export { ColumnBehaviorError, SchemaExpressionError, SchemaMetadataValidationError, SchemaValidationError, alias, assertSchemaDialectSupport, bigint, binary, boolean, canonicalLiteral, catalogCheck, catalogForeignKey, check, column, columnResultValue, createSchemaDialect, createSource, customSource, date, defaultSchemaNamingPolicy, defineSchemaExpression, dialectMismatchDiagnostic, encodeColumnParameter, exposeColumns, externalDefault, externalGeneratedColumn, foreignKey, freezeSchemaMetadata, generatedColumn, generatedSchemaObjectName, generatedTableName, identityColumn, index, integer, isUnsafeSchemaSql, isValidSchemaObjectName, json, lateral, materializeSchemaObjectIdentity, materializeSchemaObjectRecord, nativeColumn, nativeStorage, normalizeSchemaSql, nullable, numeric, portableStorage, primaryKey, references, renderSchemaExpression, renderSchemaSql, resolveColumnBehavior, schema, schemaExpression, schemaNamingPolicyVersion, sourceIdentity, table, text, timestamp, unique, uniqueConstraint, unsafeSchemaSql, uuid, validateConstraintDialect, validateIndexDialect };