qubu 0.0.0 → 0.3.3

package/dist/table-llv9tsZ8.mjs

@@ -0,0 +1,384 @@
+import { h as parenthesize, i as identifier, s as isSchemaExpression, t as createColumnReference } from "./column-CXMxx8Hq.mjs";
+import { t as resolveSqlNames } from "./naming-QVCOnSj2.mjs";
+import { r as exposeColumns, t as createSource } from "./source-DUoJVXmL.mjs";
+import { M as materializeSchemaObjectRecord, O as freezeSchemaMetadata } from "./registry-BufIskVN.mjs";
+//#region src/schema/alias.ts
+function alias(sourceOrQuery, name) {
+	const input = sourceOrQuery;
+	const reference = identifier(name);
+	const isQuery = "queryKind" in input;
+	const source = createSource(isQuery ? "query-alias" : "table-alias", (context) => {
+		if (isQuery) context.renderRelation(parenthesize(input));
+		else context.render(input);
+		context.append(" AS ");
+		context.render(reference);
+	}, reference);
+	const fieldNames = isQuery ? Object.keys(input.row) : Object.keys(input.columns);
+	const querySqlNames = isQuery ? resolveSqlNames(fieldNames.map((fieldName) => ({ fieldName }))) : void 0;
+	const columns = Object.fromEntries(fieldNames.map((fieldName) => {
+		const columnName = isQuery ? querySqlNames[fieldName] : input.columns[fieldName].columnName;
+		return [fieldName, createColumnReference(columnName, reference, fieldName)];
+	}));
+	Object.assign(source, {
+		alias: name,
+		base: isQuery ? void 0 : input,
+		query: isQuery ? input : void 0,
+		constraints: isQuery ? {} : input.constraints,
+		indexes: isQuery ? {} : "indexes" in input ? input.indexes : {},
+		columns
+	});
+	exposeColumns(source, columns);
+	return source;
+}
+/** Render a query as a LATERAL source whose outer requirements stay visible. */
+function lateral(query, name) {
+	const reference = identifier(name);
+	const source = createSource("lateral", (context) => {
+		context.append("LATERAL ");
+		context.renderRelation(parenthesize(query));
+		context.append(" AS ");
+		context.render(reference);
+	}, reference);
+	const sqlNames = resolveSqlNames(Object.keys(query.row).map((fieldName) => ({ fieldName })));
+	const columns = Object.fromEntries(Object.keys(query.row).map((fieldName) => [fieldName, createColumnReference(sqlNames[fieldName], reference, fieldName)]));
+	Object.assign(source, {
+		alias: name,
+		query,
+		columns
+	});
+	exposeColumns(source, columns);
+	return source;
+}
+//#endregion
+//#region src/schema/column-behavior.ts
+/** A column behavior error with a stable code and optional property path. */
+var ColumnBehaviorError = class extends TypeError {
+	code;
+	path;
+	constructor(code, message, path) {
+		super(message);
+		this.name = "ColumnBehaviorError";
+		this.code = code;
+		this.path = path;
+	}
+};
+/** Build a canonical literal node from a supported JavaScript scalar. */
+function canonicalLiteral(value) {
+	if (value === null) return Object.freeze({ kind: "null" });
+	if (typeof value === "boolean") return Object.freeze({
+		kind: "boolean",
+		value
+	});
+	if (typeof value === "string") return Object.freeze({
+		kind: "string",
+		value
+	});
+	if (typeof value === "bigint") return Object.freeze({
+		kind: "bigint",
+		value: String(value)
+	});
+	if (!Number.isFinite(value)) throw new ColumnBehaviorError("invalid-default", "Default literal numbers must be finite", "default.value");
+	return Object.freeze({
+		kind: "number",
+		value: Object.is(value, -0) ? "0" : String(value)
+	});
+}
+function literalDefault(value) {
+	return Object.freeze({
+		kind: "literal",
+		value: canonicalLiteral(value)
+	});
+}
+/** Normalize a public default input into its canonical snapshot descriptor. */
+function normalizeDefault(value) {
+	if (isSchemaExpression(value)) return Object.freeze({
+		kind: "expression",
+		expression: value
+	});
+	if (isExternalDefaultDescriptor(value)) return externalDefault();
+	return literalDefault(value);
+}
+/** Mark a legacy or externally managed database default explicitly. */
+function externalDefault() {
+	return Object.freeze({ kind: "external" });
+}
+/** Create an immutable generated-column descriptor. */
+function generatedColumn(expression, mode) {
+	assertSchemaExpression(expression, "generatedColumn.expression", "invalid-generated-column");
+	const resolvedMode = typeof mode === "string" ? mode : mode?.mode ?? "stored";
+	if (resolvedMode !== "stored" && resolvedMode !== "virtual") throw new ColumnBehaviorError("invalid-generated-column", `Generated-column mode must be "stored" or "virtual", received "${String(resolvedMode)}"`, "generatedColumn.mode");
+	return Object.freeze({
+		kind: "expression",
+		expression,
+		mode: resolvedMode
+	});
+}
+/** Mark a legacy or externally managed generated column explicitly. */
+function externalGeneratedColumn() {
+	return Object.freeze({ kind: "external" });
+}
+/** Describe a database identity column without inventing a generated SQL expression. */
+function identityColumn(generation, options) {
+	const resolvedGeneration = generation ?? "by-default";
+	if (resolvedGeneration !== "always" && resolvedGeneration !== "by-default") throw new ColumnBehaviorError("invalid-identity", `Identity generation must be "always" or "by-default", received "${String(resolvedGeneration)}"`, "identity.generation");
+	return Object.freeze({
+		kind: "identity",
+		generation: resolvedGeneration,
+		...options?.dialect === void 0 ? {} : { dialect: freezeSchemaMetadata(options.dialect) }
+	});
+}
+/** Normalize complete and legacy column behavior into immutable metadata. */
+function resolveColumnBehavior(options) {
+	const hasDefaultFlag = options.hasDefault === true;
+	const generatedFlag = options.generated === true;
+	const defaultDescriptor = options.default === void 0 ? void 0 : normalizeDefault(options.default);
+	const generatedDescriptor = options.generatedColumn;
+	const identityDescriptor = options.identity;
+	const onUpdateExpression = options.onUpdate;
+	if (onUpdateExpression !== void 0 && !isSchemaExpression(onUpdateExpression)) throw new ColumnBehaviorError("invalid-on-update", "Column onUpdate metadata must carry the deterministic schema-expression brand", "onUpdate");
+	if (defaultDescriptor !== void 0) {
+		assertDefaultDescriptor(defaultDescriptor);
+		if (options.hasDefault === false) throw new ColumnBehaviorError("default-flag-conflict", "A complete default descriptor cannot be combined with hasDefault: false", "hasDefault");
+		if (generatedDescriptor !== void 0 || identityDescriptor !== void 0) throw new ColumnBehaviorError("default-generated-conflict", "A column cannot declare a complete default together with generated-column or identity metadata", "default");
+		if (generatedFlag) throw new ColumnBehaviorError("default-generated-conflict", "A complete default descriptor cannot be combined with generated: true", "default");
+	}
+	if (generatedDescriptor !== void 0) {
+		assertGeneratedColumnDescriptor(generatedDescriptor);
+		if (options.generated === false) throw new ColumnBehaviorError("generated-flag-conflict", "A complete generated-column descriptor cannot be combined with generated: false", "generated");
+		if (identityDescriptor !== void 0) throw new ColumnBehaviorError("identity-generated-conflict", "A column cannot declare both generated-column and identity metadata", "generatedColumn");
+		if (hasDefaultFlag) throw new ColumnBehaviorError("default-generated-conflict", "A complete generated-column descriptor cannot be combined with hasDefault: true", "generatedColumn");
+	}
+	if (identityDescriptor !== void 0) {
+		assertIdentityDescriptor(identityDescriptor);
+		if (options.generated === false) throw new ColumnBehaviorError("generated-flag-conflict", "Identity metadata cannot be combined with generated: false", "generated");
+		if (hasDefaultFlag) throw new ColumnBehaviorError("identity-generated-conflict", "Identity metadata cannot be combined with hasDefault: true", "identity");
+	}
+	const normalizedDefault = defaultDescriptor === void 0 ? void 0 : freezeDefaultDescriptor(defaultDescriptor);
+	const normalizedGenerated = generatedDescriptor === void 0 ? void 0 : freezeGeneratedColumnDescriptor(generatedDescriptor);
+	const normalizedIdentity = identityDescriptor === void 0 ? void 0 : freezeIdentityDescriptor(identityDescriptor);
+	return Object.freeze({
+		hasDefault: hasDefaultFlag || normalizedDefault !== void 0,
+		generated: generatedFlag || normalizedGenerated !== void 0 || normalizedIdentity !== void 0,
+		default: normalizedDefault ?? (hasDefaultFlag ? externalDefault() : void 0),
+		generatedColumn: normalizedGenerated ?? (generatedFlag && normalizedIdentity === void 0 ? externalGeneratedColumn() : void 0),
+		identity: normalizedIdentity,
+		onUpdate: onUpdateExpression
+	});
+}
+function freezeDefaultDescriptor(value) {
+	if (value.kind === "external") return externalDefault();
+	if (value.kind === "expression") return Object.freeze({
+		kind: "expression",
+		expression: value.expression
+	});
+	return Object.freeze({
+		kind: "literal",
+		value: Object.freeze({ ...value.value })
+	});
+}
+function isExternalDefaultDescriptor(value) {
+	return typeof value === "object" && value !== null && value.kind === "external";
+}
+function freezeGeneratedColumnDescriptor(value) {
+	if (value.kind === "external") return externalGeneratedColumn();
+	return Object.freeze({
+		kind: "expression",
+		expression: value.expression,
+		mode: value.mode
+	});
+}
+function freezeIdentityDescriptor(value) {
+	return Object.freeze({
+		kind: "identity",
+		generation: value.generation,
+		...value.dialect === void 0 ? {} : { dialect: freezeSchemaMetadata(value.dialect) }
+	});
+}
+function assertSchemaExpression(expression, path, code = "invalid-default") {
+	if (!isSchemaExpression(expression)) throw new ColumnBehaviorError(code, "Schema behavior expressions must carry the deterministic schema-expression brand", path);
+}
+function assertDefaultDescriptor(value) {
+	if (!value || typeof value !== "object") throw new ColumnBehaviorError("invalid-default", "Column default metadata must be an object", "default");
+	if (value.kind === "external") return;
+	if (value.kind === "expression") {
+		assertSchemaExpression(value.expression, "default.expression");
+		return;
+	}
+	if (value.kind === "literal") {
+		assertCanonicalLiteral(value.value);
+		return;
+	}
+	throw new ColumnBehaviorError("invalid-default", "Unknown column default descriptor kind", "default.kind");
+}
+function assertGeneratedColumnDescriptor(value) {
+	if (!value || typeof value !== "object") throw new ColumnBehaviorError("invalid-generated-column", "Generated-column metadata must be an object", "generatedColumn");
+	if (value.kind === "external") return;
+	if (value.kind === "expression") {
+		assertSchemaExpression(value.expression, "generatedColumn.expression", "invalid-generated-column");
+		if (value.mode !== "stored" && value.mode !== "virtual") throw new ColumnBehaviorError("invalid-generated-column", "Generated-column mode must be \"stored\" or \"virtual\"", "generatedColumn.mode");
+		return;
+	}
+	throw new ColumnBehaviorError("invalid-generated-column", "Unknown generated-column descriptor kind", "generatedColumn.kind");
+}
+function assertIdentityDescriptor(value) {
+	if (!value || typeof value !== "object" || value.kind !== "identity" || value.generation !== "always" && value.generation !== "by-default") throw new ColumnBehaviorError("invalid-identity", "Identity metadata must use generation \"always\" or \"by-default\"", "identity.generation");
+	if (value.dialect !== void 0) {
+		if (typeof value.dialect !== "object" || value.dialect === null || typeof value.dialect.dialect !== "string" || value.dialect.dialect.length === 0) throw new ColumnBehaviorError("invalid-identity", "Identity dialect metadata must contain a non-empty dialect tag", "identity.dialect");
+	}
+}
+function assertCanonicalLiteral(value) {
+	if (!value || typeof value !== "object") throw new ColumnBehaviorError("invalid-default", "Literal defaults must contain a canonical literal node", "default.value");
+	switch (value.kind) {
+		case "null": return;
+		case "boolean":
+			if (typeof value.value === "boolean") return;
+			break;
+		case "string":
+			if (typeof value.value === "string") return;
+			break;
+		case "number":
+			if (typeof value.value === "string" && value.value.length > 0) return;
+			break;
+		case "bigint": if (/^-?(0|[1-9][0-9]*)$/.test(value.value)) return;
+	}
+	throw new ColumnBehaviorError("invalid-default", "Literal defaults must contain a valid canonical literal node", "default.value");
+}
+//#endregion
+//#region src/schema/column.ts
+/** Create an immutable portable physical storage descriptor. */
+function portableStorage(type) {
+	return Object.freeze({
+		kind: "portable",
+		type
+	});
+}
+function nativeStorage(dialectOrOptions, type) {
+	const dialect = typeof dialectOrOptions === "string" ? dialectOrOptions : dialectOrOptions.dialect;
+	const declaration = typeof dialectOrOptions === "string" ? type : "type" in dialectOrOptions ? dialectOrOptions.type : dialectOrOptions.declaration;
+	return Object.freeze({
+		kind: "native",
+		dialect,
+		type: declaration
+	});
+}
+function narrowColumnType() {
+	return this;
+}
+function withPortableCast(definition, type) {
+	return Object.freeze({
+		...definition,
+		castTarget: Object.freeze({
+			kind: "portable-cast",
+			type
+		})
+	});
+}
+function withPortableStorage(definition, type) {
+	return Object.freeze({
+		...definition,
+		storage: portableStorage(type)
+	});
+}
+function column(options) {
+	return Object.freeze({
+		definitionKind: "column",
+		nullable: options?.nullable === true,
+		...resolveColumnBehavior(options ?? {}),
+		sqlName: options?.sqlName,
+		storage: options?.storage ? Object.freeze({ ...options.storage }) : void 0,
+		$type: narrowColumnType,
+		castTarget: options?.castType ? Object.freeze({
+			kind: "named-cast",
+			typeName: options.castType
+		}) : void 0
+	});
+}
+function nativeColumn(storageOrDialect, typeOrOptions, maybeOptions) {
+	const storage = typeof storageOrDialect === "string" ? nativeStorage(storageOrDialect, typeOrOptions) : storageOrDialect;
+	return column({
+		...(typeof storageOrDialect === "string" ? maybeOptions : typeOrOptions) ?? {},
+		storage
+	});
+}
+function nullable(definition) {
+	return Object.freeze({
+		...definition,
+		nullable: true
+	});
+}
+function integer(options) {
+	return withPortableStorage(withPortableCast(column(options), "integer"), "integer");
+}
+function numeric(options) {
+	return withPortableStorage(withPortableCast(column(options), "decimal"), "numeric");
+}
+function text(options) {
+	return withPortableStorage(withPortableCast(column(options), "text"), "text");
+}
+function boolean(options) {
+	return withPortableStorage(withPortableCast(column(options), "boolean"), "boolean");
+}
+function date(options) {
+	return withPortableStorage(withPortableCast(column(options), "date"), "date");
+}
+function timestamp(options) {
+	return withPortableStorage(withPortableCast(column(options), "timestamp"), "timestamp");
+}
+function uuid(options) {
+	return withPortableStorage(withPortableCast(column(options), "uuid"), "uuid");
+}
+function json(options) {
+	return withPortableStorage(withPortableCast(column(options), "json"), "json");
+}
+function bigint(options) {
+	return withPortableStorage(withPortableCast(column(options), "bigint"), "bigint");
+}
+function binary(options) {
+	return withPortableStorage(withPortableCast(column(options), "binary"), "binary");
+}
+//#endregion
+//#region src/schema/table.ts
+function table(name, definitions, metadata) {
+	const source = createSource("table", (context) => context.render(identifier(name)), identifier(name));
+	const sqlNames = resolveSqlNames(Object.entries(definitions).map(([fieldName, definition]) => ({
+		fieldName,
+		sqlName: definition.sqlName
+	})));
+	const columns = Object.fromEntries(Object.keys(definitions).map((fieldName) => {
+		const sqlName = sqlNames[fieldName];
+		return [fieldName, createColumnReference(sqlName, source.reference, fieldName)];
+	}));
+	Object.assign(source, {
+		tableName: name,
+		definitions,
+		sqlNames,
+		columns,
+		constraints: {},
+		indexes: {}
+	});
+	exposeColumns(source, columns);
+	const resolvedMetadata = metadata ? metadata(source) : {
+		constraints: {},
+		indexes: {}
+	};
+	const constraints = materializeSchemaObjectRecord(resolvedMetadata.constraints, "constraint");
+	const indexes = Object.fromEntries(Object.entries(resolvedMetadata.indexes).map(([indexName, tableIndex]) => {
+		const candidateKey = tableIndex.unique && tableIndex.predicate === void 0 && tableIndex.terms.every((term) => {
+			const expression = "orderKind" in term ? term.expression : term;
+			return expression.expressionKind === "column" && definitions[expression.fieldName]?.nullable === false;
+		});
+		return [indexName, Object.freeze({
+			...tableIndex,
+			candidateKey
+		})];
+	}));
+	const namedIndexes = materializeSchemaObjectRecord(indexes, "index");
+	Object.assign(source, {
+		...resolvedMetadata,
+		constraints,
+		indexes: namedIndexes
+	});
+	return source;
+}
+//#endregion
+export { resolveColumnBehavior as C, identityColumn as S, lateral as T, ColumnBehaviorError as _, column as a, externalGeneratedColumn as b, json as c, nullable as d, numeric as f, uuid as g, timestamp as h, boolean as i, nativeColumn as l, text as m, bigint as n, date as o, portableStorage as p, binary as r, integer as s, table as t, nativeStorage as u, canonicalLiteral as v, alias as w, generatedColumn as x, externalDefault as y };