qubu 0.3.5 → 0.4.1

package/dist/column-hqKr7-1I.mjs

@@ -0,0 +1,620 @@
+import { a as assertDialectCapability } from "./json-Db7XRD91.mjs";
+//#region src/result.ts
+const resultValueMetadata = Symbol("qubu.result-value-metadata");
+function resultValue(type, decoder) {
+	return type === void 0 && decoder === void 0 ? void 0 : Object.freeze({
+		...type === void 0 ? {} : { type },
+		...decoder === void 0 ? {} : { decoder }
+	});
+}
+function resultValueOf(value) {
+	if (typeof value !== "object" || value === null) return;
+	return value[resultValueMetadata];
+}
+function attachResultValue(value, metadata) {
+	if (metadata === void 0) return value;
+	return Object.freeze({
+		...value,
+		[resultValueMetadata]: metadata
+	});
+}
+function createResultShape(fields) {
+	return Object.freeze({ fields: Object.freeze(fields.map((field) => Object.freeze({ ...field }))) });
+}
+function resultShapeValue(shape, name) {
+	const field = shape.fields.find((candidate) => candidate.name === name);
+	return field === void 0 ? void 0 : resultValue(field.type, field.decoder);
+}
+/** Decode SQLite/MySQL-style boolean values while accepting native booleans. */
+const booleanResultDecoder = (value) => {
+	if (typeof value === "boolean") return value;
+	if (value === 0 || value === 0n) return false;
+	if (value === 1 || value === 1n) return true;
+	throw new TypeError("Expected a boolean or numeric 0/1 result");
+};
+/** Decode a SQL DATE string as a JavaScript Date at UTC midnight. */
+const dateResultDecoder = (value) => {
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+	if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/u.test(value)) throw new TypeError("Expected a valid Date or YYYY-MM-DD result");
+	const decoded = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+	if (Number.isNaN(decoded.getTime()) || decoded.toISOString().slice(0, 10) !== value) throw new TypeError("Expected a valid calendar date result");
+	return decoded;
+};
+/** Decode a SQL/ISO timestamp string while accepting driver-created Dates. */
+const timestampResultDecoder = (value) => {
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+	if (typeof value !== "string") throw new TypeError("Expected a valid Date or timestamp string result");
+	const normalized = value.includes("T") ? value : value.replace(" ", "T");
+	const decoded = new Date(/(?:Z|[+-]\d{2}:?\d{2})$/u.test(normalized) ? normalized : `${normalized}Z`);
+	if (Number.isNaN(decoded.getTime())) throw new TypeError("Expected a valid timestamp result");
+	return decoded;
+};
+/** Decode a serialized JSON result. Use only when the adapter returns JSON text. */
+const jsonTextResultDecoder = (value) => {
+	if (typeof value !== "string") return value;
+	return JSON.parse(value);
+};
+/** Error raised when a projected driver value cannot be decoded. */
+var ResultDecodingError = class extends TypeError {
+	name = "ResultDecodingError";
+	field;
+	rowIndex;
+	resultType;
+	constructor(field, rowIndex, resultType) {
+		super(`Could not decode result field "${field}" in row ${rowIndex}${resultType === void 0 ? "" : ` as ${resultType}`}`);
+		this.field = field;
+		this.rowIndex = rowIndex;
+		this.resultType = resultType;
+	}
+};
+function decodeResultRow(row, shape, decoders, dialect, rowIndex) {
+	let decoded;
+	for (const field of shape.fields) {
+		const decoder = field.decoder ?? (field.type ? decoders?.[field.type] : void 0);
+		if (decoder === void 0 || row[field.name] === null) continue;
+		try {
+			decoded ??= { ...row };
+			decoded[field.name] = decoder(row[field.name], {
+				dialect,
+				field: field.name,
+				rowIndex
+			});
+		} catch {
+			throw new ResultDecodingError(field.name, rowIndex, field.type);
+		}
+	}
+	return decoded ?? row;
+}
+//#endregion
+//#region src/core/fragment.ts
+function fragment(render) {
+	return Object.freeze({ render });
+}
+function sequence(parts, separator = " ") {
+	return fragment((context) => {
+		let first = true;
+		for (const part of parts) {
+			if (!first) context.append(separator);
+			context.render(part);
+			first = false;
+		}
+	});
+}
+function parenthesize(part) {
+	return fragment((context) => {
+		context.append("(");
+		context.render(part);
+		context.append(")");
+	});
+}
+function isFragment(value) {
+	return typeof value === "object" && value !== null && "render" in value && typeof value.render === "function";
+}
+//#endregion
+//#region src/expressions/types.ts
+/** Runtime/type-level proof that an expression is safe to use in schema SQL. */
+const schemaExpressionBrand = Symbol("qubu.schema-expression");
+/** Add a concrete dialect requirement without dropping expression metadata. */
+function withDialectCapability(expression, capability) {
+	const wrapped = makeExpression(expression.expressionKind, (context) => {
+		assertDialectCapability(context.dialect, capability);
+		context.render(expression);
+	}, expression.expressionCategory, resultValueOf(expression));
+	return isSchemaExpression(expression) ? markSchemaExpression(wrapped) : wrapped;
+}
+function makeExpression(expressionKind, render, expressionCategory, result) {
+	return attachResultValue(Object.freeze({
+		expressionKind,
+		...expressionCategory ? { expressionCategory } : {},
+		...fragment(render)
+	}), result);
+}
+/** Mark a query-only expression category without changing its SQL renderer. */
+function markExpressionCategory(expression, category) {
+	return Object.freeze({
+		...expression,
+		expressionCategory: category
+	});
+}
+/**
+* Mark a built-in or explicitly audited renderer as schema-deterministic. Prefer
+* {@link defineSchemaExpression} for application extensions because it supplies a restricted schema
+* rendering context.
+*/
+function makeSchemaExpression(expressionKind, render, result) {
+	const expression = makeExpression(expressionKind, render, void 0, result);
+	return Object.freeze({
+		...expression,
+		[schemaExpressionBrand]: true
+	});
+}
+/** Add the schema-determinism brand to an explicitly audited expression. */
+function markSchemaExpression(expression) {
+	if (isSchemaExpression(expression)) return expression;
+	return Object.freeze({
+		...expression,
+		[schemaExpressionBrand]: true
+	});
+}
+/** Test the runtime brand used by schema rendering and validation. */
+function isSchemaExpression(value) {
+	return typeof value === "object" && value !== null && schemaExpressionBrand in value && value[schemaExpressionBrand] === true;
+}
+function isExpression(value) {
+	return typeof value === "object" && value !== null && "expressionKind" in value && "render" in value && typeof value.render === "function";
+}
+//#endregion
+//#region src/core/naming.ts
+/** Convert an application-facing field name to a SQL-facing identifier. */
+function snakeCaseIdentifier(name) {
+	return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+function resolveSqlNames(fields) {
+	const sqlNames = {};
+	const fieldsBySqlName = /* @__PURE__ */ new Map();
+	for (const field of fields) {
+		const sqlName = field.sqlName ?? snakeCaseIdentifier(field.fieldName);
+		if (sqlName.length === 0) throw new Error(`SQL name for field "${field.fieldName}" cannot be empty`);
+		const existingField = fieldsBySqlName.get(sqlName);
+		if (existingField) throw new Error(`Fields "${existingField}" and "${field.fieldName}" both resolve to SQL name "${sqlName}"`);
+		fieldsBySqlName.set(sqlName, field.fieldName);
+		sqlNames[field.fieldName] = sqlName;
+	}
+	return Object.freeze(sqlNames);
+}
+//#endregion
+//#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;
+	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/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,
+		...options?.decode === void 0 ? {} : { resultDecoder: options.decode },
+		$type: narrowColumnType,
+		castTarget: options?.castType ? Object.freeze({
+			kind: "named-cast",
+			typeName: options.castType
+		}) : void 0
+	});
+}
+/** Resolve the runtime result metadata carried by a column definition. */
+function columnResultValue(definition) {
+	const storage = definition.storage;
+	return resultValue(storage?.kind === "portable" && (storage.type === "boolean" || storage.type === "date" || storage.type === "timestamp" || storage.type === "json") ? storage.type : void 0, definition.resultDecoder);
+}
+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/core/primitives/identifier.ts
+function identifier(name) {
+	return fragment((context) => context.append(context.dialect.quoteIdentifier(name)));
+}
+function qualifiedIdentifier(...parts) {
+	return fragment((context) => {
+		parts.forEach((part, index) => {
+			if (index > 0) context.append(".");
+			context.append(context.dialect.quoteIdentifier(part));
+		});
+	});
+}
+//#endregion
+//#region src/expressions/column.ts
+function createColumnReference(columnName, sourceReference, fieldName, result) {
+	const expression = makeSchemaExpression("column", (context) => {
+		if (context.renderColumnReference) {
+			context.renderColumnReference(columnName);
+			return;
+		}
+		context.render(sourceReference);
+		context.append(".");
+		context.render(identifier(columnName));
+	}, result);
+	return Object.freeze({
+		...expression,
+		fieldName,
+		columnName
+	});
+}
+function isColumnReference(value) {
+	return typeof value === "object" && value !== null && "expressionKind" in value && value.expressionKind === "column";
+}
+/** Turn an expression into a fragment that renders it without changing it. */
+function expressionFragment(expression) {
+	return fragment((context) => context.render(expression));
+}
+//#endregion
+export { dateResultDecoder as $, assertSchemaDialectSupport as A, isSchemaExpression as B, canonicalLiteral as C, identityColumn as D, generatedColumn as E, materializeSchemaObjectIdentity as F, withDialectCapability as G, makeSchemaExpression as H, materializeSchemaObjectRecord as I, parenthesize as J, fragment as K, resolveSqlNames as L, freezeSchemaMetadata as M, generatedSchemaObjectName as N, resolveColumnBehavior as O, isValidSchemaObjectName as P, createResultShape as Q, snakeCaseIdentifier as R, ColumnBehaviorError as S, externalGeneratedColumn as T, markExpressionCategory as U, makeExpression as V, markSchemaExpression as W, ResultDecodingError as X, sequence as Y, booleanResultDecoder as Z, numeric as _, qualifiedIdentifier as a, timestampResultDecoder as at, timestamp as b, boolean as c, date as d, decodeResultRow as et, integer as f, nullable as g, nativeStorage as h, identifier as i, resultValueOf as it, dialectMismatchDiagnostic as j, SchemaMetadataValidationError as k, column as l, nativeColumn as m, expressionFragment as n, resultShapeValue as nt, bigint as o, json as p, isFragment as q, isColumnReference as r, resultValue as rt, binary as s, createColumnReference as t, jsonTextResultDecoder as tt, columnResultValue as u, portableStorage as v, externalDefault as w, uuid as x, text as y, isExpression as z };