qubu 0.0.0 → 0.3.4

package/dist/registry-BufIskVN.mjs

@@ -0,0 +1,569 @@
+import { t as standardDialect } from "./standard-BTVYKh_F.mjs";
+import { d as markSchemaExpression, l as makeSchemaExpression, r as isColumnReference, s as isSchemaExpression } from "./column-CXMxx8Hq.mjs";
+import { n as isValueExpression } from "./value-BvilP0oz.mjs";
+import { n as snakeCaseIdentifier } from "./naming-QVCOnSj2.mjs";
+//#region src/schema/metadata.ts
+/** Error raised when relational metadata cannot be represented safely. */
+var SchemaMetadataValidationError = class extends TypeError {
+	name = "SchemaMetadataValidationError";
+	diagnostics;
+	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;
+	}
+};
+/** Generate the version-one physical name for a relational object ID. */
+function generatedSchemaObjectName(id) {
+	return snakeCaseIdentifier(id);
+}
+/** Deep-freeze plain metadata values without introducing executable nodes. */
+function freezeSchemaMetadata(value) {
+	if (Array.isArray(value)) return Object.freeze(value.map((item) => freezeSchemaMetadata(item)));
+	if (typeof value !== "object" || value === null) return value;
+	const frozen = Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, freezeSchemaMetadata(nested)]));
+	return Object.freeze(frozen);
+}
+/** Check the portable identifier subset used for generated metadata names. */
+function isValidSchemaObjectName(name) {
+	return name.length > 0 && name === name.trim() && !/[.\\/\u0000-\u001f\u007f"']/u.test(name);
+}
+/**
+* Attach a record key and resolved physical name without changing the
+* enumerable shape of legacy constraint/index values. The properties are
+* still ordinary read-only runtime metadata and are available to snapshot
+* traversals.
+*/
+function materializeSchemaObjectIdentity(value, id, physicalName) {
+	const materialized = { ...value };
+	Object.defineProperties(materialized, {
+		id: {
+			configurable: false,
+			enumerable: false,
+			value: id,
+			writable: false
+		},
+		physicalName: {
+			configurable: false,
+			enumerable: false,
+			value: physicalName ?? generatedSchemaObjectName(id),
+			writable: false
+		}
+	});
+	return Object.freeze(materialized);
+}
+/**
+* Resolve and validate names for one metadata record. The caller decides
+* whether constraint and index names share a database namespace.
+*/
+function materializeSchemaObjectRecord(record, kind) {
+	const diagnostics = [];
+	const names = /* @__PURE__ */ new Map();
+	const result = {};
+	for (const [id, value] of Object.entries(record)) {
+		const physicalName = value.physicalName ?? generatedSchemaObjectName(id);
+		const path = [kind === "constraint" ? "constraints" : "indexes", id];
+		if (!isValidSchemaObjectName(physicalName)) diagnostics.push({
+			code: "invalid-physical-name",
+			message: `The ${kind} "${id}" has invalid physical name "${physicalName}"`,
+			path: [...path, "physicalName"]
+		});
+		const previousId = names.get(physicalName);
+		if (previousId !== void 0) diagnostics.push({
+			code: "duplicate-physical-name",
+			message: `The ${kind}s "${previousId}" and "${id}" both use physical name "${physicalName}"`,
+			path: [...path, "physicalName"],
+			relatedPaths: [[
+				kind === "constraint" ? "constraints" : "indexes",
+				previousId,
+				"physicalName"
+			]]
+		});
+		else names.set(physicalName, id);
+		result[id] = materializeSchemaObjectIdentity(value, id, physicalName);
+	}
+	if (diagnostics.length > 0) throw new SchemaMetadataValidationError(diagnostics);
+	return Object.freeze(result);
+}
+/** Return a diagnostic when a dialect extension is used by another adapter. */
+function dialectMismatchDiagnostic(extension, dialect, path) {
+	if (extension.dialect === dialect) return void 0;
+	return {
+		code: "dialect-mismatch",
+		message: `Dialect extension belongs to "${extension.dialect}" but the active schema dialect is "${dialect}"`,
+		path,
+		dialect
+	};
+}
+/** Throw a structured error for one or more dialect capability findings. */
+function assertSchemaDialectSupport(diagnostics) {
+	if (diagnostics.length > 0) throw new SchemaMetadataValidationError(diagnostics);
+}
+//#endregion
+//#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/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/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
+//#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 { isValidSchemaObjectName as A, index as C, dialectMismatchDiagnostic as D, assertSchemaDialectSupport as E, materializeSchemaObjectRecord as M, freezeSchemaMetadata as O, unsafeSchemaSql as S, SchemaMetadataValidationError as T, isUnsafeSchemaSql as _, schemaNamingPolicyVersion as a, renderSchemaSql as b, check as c, references as d, unique as f, defineSchemaExpression as g, SchemaExpressionError as h, schema as i, materializeSchemaObjectIdentity as j, generatedSchemaObjectName as k, foreignKey as l, validateConstraintDialect as m, defaultSchemaNamingPolicy as n, catalogCheck as o, uniqueConstraint as p, generatedTableName as r, catalogForeignKey as s, SchemaValidationError as t, primaryKey as u, normalizeSchemaSql as v, validateIndexDialect as w, schemaExpression as x, renderSchemaExpression as y };

package/dist/relational-DCZrrNia.mjs

@@ -0,0 +1,77 @@
+import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
+import { l as makeSchemaExpression } from "./column-CXMxx8Hq.mjs";
+import { n as isValueExpression, t as asValue } from "./value-BvilP0oz.mjs";
+//#region src/expressions/operators/shared.ts
+function isNullOperand(value) {
+	return value === null || isValueExpression(value) && value.value === null;
+}
+function expressionOperand(operand) {
+	return asValue(operand);
+}
+function renderOperands(context, operands, separator) {
+	operands.forEach((operand, index) => {
+		if (index > 0) context.append(separator);
+		context.render(operand);
+	});
+}
+//#endregion
+//#region src/expressions/operators/comparison/relational.ts
+function comparison(operator, left, right) {
+	if (isNullOperand(right)) {
+		if (operator === "=" || operator === "<>") {
+			const nullOperator = operator === "=" ? "IS NULL" : "IS NOT NULL";
+			return makeSchemaExpression("operator", (context) => {
+				context.append("(");
+				context.render(left);
+				context.append(` ${nullOperator})`);
+			});
+		}
+		if (operator !== "IS DISTINCT FROM" && operator !== "IS NOT DISTINCT FROM") throw queryValidationError({
+			code: "invalid-comparison",
+			context: "expression.comparison.null",
+			path: ["comparison", operator],
+			message: `Cannot compare NULL with ${operator}; use isNull(), isNotNull(), or a distinctness predicate`,
+			hint: "Use isNull(), isNotNull(), or a distinctness predicate for NULL comparisons."
+		});
+	}
+	const rightExpression = expressionOperand(right);
+	return makeSchemaExpression("operator", (context) => {
+		context.append("(");
+		context.render(left);
+		context.append(` ${operator} `);
+		context.render(rightExpression);
+		context.append(")");
+	});
+}
+function eq(left, right) {
+	return comparison("=", left, right);
+}
+function ne(left, right) {
+	return comparison("<>", left, right);
+}
+function lt(left, right) {
+	return comparison("<", left, right);
+}
+function lte(left, right) {
+	return comparison("<=", left, right);
+}
+function gt(left, right) {
+	return comparison(">", left, right);
+}
+function gte(left, right) {
+	return comparison(">=", left, right);
+}
+function like(left, pattern) {
+	return comparison("LIKE", left, pattern);
+}
+function notLike(left, pattern) {
+	return comparison("NOT LIKE", left, pattern);
+}
+function isDistinctFrom(left, right) {
+	return comparison("IS DISTINCT FROM", left, right);
+}
+function isNotDistinctFrom(left, right) {
+	return comparison("IS NOT DISTINCT FROM", left, right);
+}
+//#endregion
+export { isDistinctFrom as a, lt as c, notLike as d, expressionOperand as f, gte as i, lte as l, renderOperands as m, eq as n, isNotDistinctFrom as o, isNullOperand as p, gt as r, like as s, comparison as t, ne as u };