qubu 0.6.0 → 0.6.1

package/dist/mysql.d.mts

@@ -1,4 +1,4 @@
-import { V as Dialect } from "./types-C0VkiwpR.mjs";
+import { V as Dialect } from "./types-DUe6eeI0.mjs";
 //#region src/dialects/mysql.d.ts
 declare function mysqlDialect(): Dialect<"json" | "row-locking">;
 //#endregion

package/dist/mysql.mjs

@@ -14,7 +14,7 @@ const mysqlRowLocking = { render(context, mode, wait) {
 	if (wait === "nowait") context.append(" NOWAIT");
 	if (wait === "skip-locked") context.append(" SKIP LOCKED");
 } };
-function renderMySqlPagination(context, parts) {
+function renderPagination(context, parts) {
 	const fetch = parts.find((part) => part.kind === "fetch");
 	const offset = parts.find((part) => part.kind === "offset");
 	context.append("LIMIT ");
@@ -30,7 +30,7 @@ function mysqlDialect() {
 		name: "mysql",
 		quoteIdentifier: (identifier) => `\`${identifier.replaceAll("`", "``")}\``,
 		placeholder: () => "?",
-		pagination: { render: renderMySqlPagination },
+		pagination: { render: renderPagination },
 		rowLocking: mysqlRowLocking,
 		json: mysqlJson,
 		capabilities: ["row-locking"],

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

@@ -1,9 +1,10 @@
 import { a as assertDialectCapability } from "./json-Db7XRD91.mjs";
+import { O as fragment, i as identifier, t as createColumnReference, x as isExpression } from "./column-BzN8KFJa.mjs";
 import { n as queryValidationError } from "./errors-Dxv73YJu.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 { a as columnResultValue, s as encodeColumnParameter } from "./column-CFvSbil0.mjs";
 import { t as omit } from "./omit-OxV58AwX.mjs";
-import { r as exposeColumns, t as createSource } from "./source-SqrKWjFJ.mjs";
+import { r as exposeColumns, t as createSource } from "./source-BDuUXmAk.mjs";
+import { a as renderSchemaExpression, t as SchemaExpressionError } from "./expressions-BCjc08zw.mjs";
 //#region src/query/mutation/on-conflict.ts
 /** Columns from the proposed INSERT row, available inside DO UPDATE. */
 function excluded(table) {
@@ -41,12 +42,31 @@ function onConflict(...args) {
 			assertDialectCapability(context.dialect, "on-conflict");
 			context.append("ON CONFLICT");
 			if (target !== void 0) {
+				if (target.kind === "index" && context.dialect.name !== "postgresql") throw queryValidationError({
+					code: "invalid-mutation",
+					context: "upsert.conflict.target",
+					path: [
+						"onConflict",
+						"target",
+						"dialect"
+					],
+					message: "Unique-index conflict targets require the PostgreSQL dialect",
+					hint: "Render this query with postgresDialect(), or use a declared key constraint."
+				});
 				context.append(" (");
-				target.columns.forEach((column, index) => {
+				if (target.kind === "index") target.terms.forEach((term, index) => {
+					if (index > 0) context.append(", ");
+					renderConflictIndexTerm(context, term, index);
+				});
+				else target.columns.forEach((column, index) => {
 					if (index > 0) context.append(", ");
 					context.render(identifier(table?.sqlNames[column.fieldName] ?? column.columnName));
 				});
 				context.append(")");
+				if (target.kind === "index" && target.predicate !== void 0) {
+					context.append(" WHERE ");
+					context.append(renderConflictIndexExpression(context, target.predicate, "predicate"));
+				}
 			}
 			if (action.actionKind === "do-nothing") {
 				context.append(" DO NOTHING");
@@ -71,6 +91,35 @@ function onConflict(...args) {
 	});
 }
 function validateConflictTarget(table, target) {
+	if (target.kind === "index") {
+		const indexes = "indexes" in table ? table.indexes : {};
+		if (!Object.values(indexes).includes(target)) throw queryValidationError({
+			code: "invalid-mutation",
+			context: "upsert.conflict.target",
+			path: ["onConflict", "target"],
+			message: "ON CONFLICT index target must be declared on the target table",
+			hint: "Use a unique index from the INSERT target table's indexes record."
+		});
+		if (!target.unique || target.terms.length === 0) throw queryValidationError({
+			code: "invalid-mutation",
+			context: "upsert.conflict.target",
+			path: ["onConflict", "target"],
+			message: "ON CONFLICT index target must be a non-empty unique index",
+			hint: "Declare the target with index(terms, { unique: true })."
+		});
+		if (target.dialect !== void 0 && target.dialect.dialect !== "postgresql") throw queryValidationError({
+			code: "invalid-mutation",
+			context: "upsert.conflict.target",
+			path: [
+				"onConflict",
+				"target",
+				"dialect"
+			],
+			message: `ON CONFLICT cannot use an index declared for ${target.dialect.dialect}`,
+			hint: "Use a portable unique index or one declared for PostgreSQL."
+		});
+		return;
+	}
 	if (target.kind !== "primary-key" && target.kind !== "unique" || target.columns.length === 0) throw queryValidationError({
 		code: "invalid-mutation",
 		context: "upsert.conflict.target",
@@ -91,6 +140,29 @@ function validateConflictTarget(table, target) {
 		hint: "Use the key constraint declared on the INSERT target table."
 	});
 }
+function renderConflictIndexTerm(context, term, index) {
+	const expression = "orderKind" in term ? term.expression : term;
+	const text = renderConflictIndexExpression(context, expression, ["terms", index]);
+	context.append(expression.expressionKind === "column" ? text : `(${text})`);
+}
+function renderConflictIndexExpression(context, expression, path) {
+	try {
+		return renderSchemaExpression(expression, "index", context.dialect).text;
+	} catch (error) {
+		if (!(error instanceof SchemaExpressionError)) throw error;
+		throw queryValidationError({
+			code: "invalid-mutation",
+			context: "upsert.conflict.target",
+			path: [
+				"onConflict",
+				"target",
+				...typeof path === "string" ? [path] : path
+			],
+			message: `ON CONFLICT index target is not representable: ${error.message}`,
+			hint: "Use deterministic PostgreSQL index terms and a deterministic partial predicate."
+		});
+	}
+}
 function validateConflictAction(table, action) {
 	if (action.actionKind === "do-nothing") {
 		if (table === void 0) return;

package/dist/postgres-Dey7QXPL.mjs

@@ -0,0 +1,69 @@
+import { a as assertDialectCapability, n as postgresJson, o as createDialect } from "./json-Db7XRD91.mjs";
+import { D as withDialectCapability } from "./column-BzN8KFJa.mjs";
+import { t as comparison } from "./relational-DSAJ-l58.mjs";
+import { n as postgresExplain } from "./explain-CkIK13L_.mjs";
+//#region src/query/mutation/update-from.ts
+/** Introduce one or more PostgreSQL sources to an UPDATE statement. */
+function updateFrom(...sources) {
+	return Object.freeze({
+		clauseKind: "update-from",
+		sources,
+		render(context) {
+			assertDialectCapability(context.dialect, "update-from");
+			context.append("FROM ");
+			sources.forEach((source, index) => {
+				if (index > 0) context.append(", ");
+				context.render(source);
+			});
+		}
+	});
+}
+//#endregion
+//#region src/dialects/postgres.ts
+const postgresRowLockModeSql = {
+	update: "UPDATE",
+	"no-key-update": "NO KEY UPDATE",
+	share: "SHARE",
+	"key-share": "KEY SHARE"
+};
+const postgresRowLocking = { render(context, mode, wait) {
+	context.append(`FOR ${postgresRowLockModeSql[mode]}`);
+	if (wait === "nowait") context.append(" NOWAIT");
+	if (wait === "skip-locked") context.append(" SKIP LOCKED");
+} };
+const postgresPagination = { render(context, parts) {
+	[...parts].sort((left, right) => {
+		return (left.kind === "fetch" ? 0 : 1) - (right.kind === "fetch" ? 0 : 1);
+	}).forEach((part, index) => {
+		if (index > 0) context.append(" ");
+		context.append(part.kind === "fetch" ? "LIMIT " : "OFFSET ");
+		context.parameter(part.rows);
+	});
+} };
+/**
+* PostgreSQL's only core rendering difference is positional parameters. PostgreSQL-specific
+* expressions and clauses should remain separate modules.
+*/
+function postgresDialect() {
+	return createDialect({
+		name: "postgresql",
+		placeholder: (position) => `$${position}`,
+		pagination: postgresPagination,
+		rowLocking: postgresRowLocking,
+		castTypes: { binary: "BYTEA" },
+		capabilities: [
+			"ilike",
+			"on-conflict",
+			"row-locking",
+			"update-from"
+		],
+		json: postgresJson,
+		explain: postgresExplain
+	});
+}
+/** PostgreSQL's case-insensitive pattern-match operator. */
+function ilike(left, pattern) {
+	return withDialectCapability(comparison("ILIKE", left, pattern), "ilike");
+}
+//#endregion
+export { postgresDialect as n, updateFrom as r, ilike as t };

package/dist/postgres.d.mts

@@ -1,10 +1,10 @@
-import { Do as SqlCapabilityValidation, Eo as OperandSqlType, Fl as SchemaExpression, Ku as SqlBoolean, Ou as RequiresCapabilityMeta, Pl as ExpressionWithOutput, Pu as ResultMeta, To as OperandNullability, Uu as AnySqlType, V as Dialect, _n as doNothing, _u as MetadataOf, bn as onConflict, dn as ConflictAction, fn as ConflictTarget, gn as OnConflictClause, hn as ExcludedSource, id as SqlTextLike, mn as DoUpdateAction, ou as ExpressionMeta, pn as DoNothingAction, sd as SqlUnknown, so as ComparisonValidation, vn as doUpdate, wo as Operand, yn as excluded } from "./types-C0VkiwpR.mjs";
+import { Ao as OperandNullability, Bl as SchemaExpression, Dn as UpdateFromScope, En as UpdateFromClause, Ju as AnySqlType, Mo as SqlCapabilityValidation, Nu as RequiresCapabilityMeta, On as updateFrom, Sn as onConflict, Su as MetadataOf, V as Dialect, Zu as SqlBoolean, _n as ExcludedSource, bn as doUpdate, du as ExpressionMeta, fd as SqlUnknown, fo as ComparisonValidation, gn as DoUpdateAction, hn as DoNothingAction, jo as OperandSqlType, ko as Operand, ld as SqlTextLike, mn as ConflictTarget, pn as ConflictAction, vn as OnConflictClause, xn as excluded, yn as doNothing, zl as ExpressionWithOutput, zu as ResultMeta } from "./types-DUe6eeI0.mjs";
 //#region src/dialects/postgres.d.ts
 /**
  * PostgreSQL's only core rendering difference is positional parameters. PostgreSQL-specific
  * expressions and clauses should remain separate modules.
  */
-declare function postgresDialect(): Dialect<"on-conflict" | "json" | "ilike" | "row-locking">;
+declare function postgresDialect(): Dialect<"on-conflict" | "json" | "ilike" | "row-locking" | "update-from">;
 /** PostgreSQL's case-insensitive pattern-match operator. */
 declare function ilike<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, "ILIKE">, pattern: R): SchemaExpression<ResultMeta<boolean, ((MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
   readonly kind: "result";
@@ -120,4 +120,4 @@ declare function ilike<TLeft extends ExpressionWithOutput<string>, R extends Ope
   readonly kind: "result" | "cardinality";
 } ? never : T_54 : never : never) | RequiresCapabilityMeta<"ilike">, "operator">;
 //#endregion
-export { type ConflictAction, type ConflictTarget, type DoNothingAction, type DoUpdateAction, type ExcludedSource, type OnConflictClause, doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect };
+export { type ConflictAction, type ConflictTarget, type DoNothingAction, type DoUpdateAction, type ExcludedSource, type OnConflictClause, type UpdateFromClause, type UpdateFromScope, doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect, updateFrom };

package/dist/postgres.mjs

@@ -1,52 +1,3 @@
-import { n as postgresJson, o as createDialect } from "./json-Db7XRD91.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-DZQ85f1t.mjs";
-//#region src/dialects/postgres.ts
-const postgresRowLockModeSql = {
-	update: "UPDATE",
-	"no-key-update": "NO KEY UPDATE",
-	share: "SHARE",
-	"key-share": "KEY SHARE"
-};
-const postgresRowLocking = { render(context, mode, wait) {
-	context.append(`FOR ${postgresRowLockModeSql[mode]}`);
-	if (wait === "nowait") context.append(" NOWAIT");
-	if (wait === "skip-locked") context.append(" SKIP LOCKED");
-} };
-const postgresPagination = { render(context, parts) {
-	[...parts].sort((left, right) => {
-		return (left.kind === "fetch" ? 0 : 1) - (right.kind === "fetch" ? 0 : 1);
-	}).forEach((part, index) => {
-		if (index > 0) context.append(" ");
-		context.append(part.kind === "fetch" ? "LIMIT " : "OFFSET ");
-		context.parameter(part.rows);
-	});
-} };
-/**
-* PostgreSQL's only core rendering difference is positional parameters. PostgreSQL-specific
-* expressions and clauses should remain separate modules.
-*/
-function postgresDialect() {
-	return createDialect({
-		name: "postgresql",
-		placeholder: (position) => `$${position}`,
-		pagination: postgresPagination,
-		rowLocking: postgresRowLocking,
-		castTypes: { binary: "BYTEA" },
-		capabilities: [
-			"ilike",
-			"on-conflict",
-			"row-locking"
-		],
-		json: postgresJson,
-		explain: postgresExplain
-	});
-}
-/** PostgreSQL's case-insensitive pattern-match operator. */
-function ilike(left, pattern) {
-	return withDialectCapability(comparison("ILIKE", left, pattern), "ilike");
-}
-//#endregion
-export { doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect };
+import { i as onConflict, n as doUpdate, r as excluded, t as doNothing } from "./on-conflict-CnaY5qso.mjs";
+import { n as postgresDialect, r as updateFrom, t as ilike } from "./postgres-Dey7QXPL.mjs";
+export { doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect, updateFrom };

package/dist/registry-oWDiqD7i.mjs

@@ -0,0 +1,127 @@
+import { b as snakeCaseIdentifier } from "./column-BzN8KFJa.mjs";
+//#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, schema as i, defaultSchemaNamingPolicy as n, generatedTableName as r, SchemaValidationError as t };

package/dist/{relational-CxnLCqZQ.mjs → relational-DSAJ-l58.mjs}

@@ -1,6 +1,5 @@
+import { o as asValue, s as isValueExpression, w as makeSchemaExpression, z as resultValue } from "./column-BzN8KFJa.mjs";
 import { n as queryValidationError } from "./errors-Dxv73YJu.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.d.mts

@@ -1,2 +1,2 @@
-import { $i as SourceIndexesRecord, $o as ColumnStorageDialectOf, $r as generatedTableName, $s as ResolvedColumnBehavior, Ai as catalogCheck, Ar as SchemaExpressionErrorCode, As as numeric, At as SourceSqlTypeMap, Bi as AliasedSource, Bo as ColumnHasDefault, Br as renderSchemaSql, Bs as DefaultDescriptor, Bt as TableDefinitions, Ci as SourceConstraintsRecord, Cs as date, Ct as SourceColumns, Di as UniqueConstraint, Dr as createSchemaDialect, Ds as nativeColumn, Dt as SourceKind, Ei as TableLike, Er as SchemaDialectHooks, Es as json, Et as SourceIdentity, Fi as references, Fo as ColumnDefaultOf, Fr as UnsafeSchemaSqlExpression, Fs as CanonicalLiteral, Ft as exposeColumns, Gi as alias, Go as ColumnIsNullable, Gr as SchemaNamingPolicy, Gs as GeneratedColumnDescriptor, Gt as TableRow, Hi as LateralSource, Ho as ColumnIdentityOf, Hr as unsafeSchemaSql, Hs as ExpressionGeneratedColumnDescriptor, Ht as TableInsertInput, Ii as unique, Io as ColumnDefinition, Ir as defineSchemaExpression, Is as ColumnBehaviorError, It as sourceIdentity, Ji as IndexOptions, Jo as ColumnOutput, Jr as SchemaTableNames, Js as IdentityDescriptor, Jt as table, Ki as lateral, Ko as ColumnOnUpdateOf, Kr as SchemaOptions, Ks as GeneratedColumnMode, Kt as TableSqlTypes, Li as uniqueConstraint, Lo as ColumnDefinitionConfig, Lr as isUnsafeSchemaSql, Ls as ColumnBehaviorErrorCode, Lt as AnyTable, Mi as check, Mr as SchemaExpressionMode, Ms as text, Mt as UnknownSourceSqlTypes, Ni as foreignKey, Nr as SchemaRenderContext, Ns as timestamp, Nt as createSource, Oi as UniqueConstraintOptions, Or as RenderedSchemaExpression, Os as nativeStorage, Ot as SourceProvision, Pi as primaryKey, Po as ColumnCodec, Pr as SchemaRenderOptions, Ps as uuid, Pt as customSource, Qi as SourceIndex, Qo as ColumnStorageDescriptor, Qr as defaultSchemaNamingPolicy, Qs as MysqlIdentityExtension, Ri as validateConstraintDialect, Ro as ColumnFromOptions, Rr as normalizeSchemaSql, Rs as ColumnDefault, Rt as Table, Si as SourceConstraint, Ss as columnResultValue, St as Source, Ti as SqliteConstraintExtension, Tr as SchemaDialect, Ts as integer, Tt as SourceConstraints, Ui as QueryAliasIdentity, Uo as ColumnInsertInput, Ur as Schema, Us as ExternalDefaultDescriptor, Ut as TableMetadataCallback, Vi as LateralIdentity, Vo as ColumnHasRuntimeDefault, Vr as schemaExpression, Vs as ExpressionDefaultDescriptor, Vt as TableIdentity, Wi as QuerySource, Wo as ColumnIsGenerated, Wr as SchemaDiagnostic, Ws as ExternalGeneratedColumnDescriptor, Wt as TableOptions, Xi as MysqlIndexExtension, Xo as ColumnStorage, Xr as SchemaTableRegistry, Xs as IdentityGeneration, Yi as IndexTerm, Yo as ColumnSqlType, Yr as SchemaTableRecord, Ys as IdentityDialectExtension, Zi as PostgresIndexExtension, Zo as ColumnStorageDeclarationOf, Zr as SchemaValidationError, Zs as LiteralDefaultDescriptor, _c as generatedSchemaObjectName, _i as KeyConstraint, _s as StorageTypeOf, _t as AnySource, ac as generatedColumn, ai as CheckConstraint, as as DialectNativeStorage, bc as materializeSchemaObjectRecord, bi as PostgresConstraintExtension, bs as boolean, bt as ProvidedSourceIdentity, cc as SchemaDialectExtension, ci as ConstraintOptions, cs as NativeStorageDescriptor, dc as SchemaMetadataValidationError, di as FieldLikeOptions, ds as PortableStorageDescriptor, ea as SqliteIndexExtension, ec as SchemaLiteralValue, ei as schema, es as ColumnStorageKindOf, fc as SchemaObjectIdentity, fi as ForeignKeyConstraint, fs as PortableStorageType, gc as freezeSchemaMetadata, gi as ForeignKeyTargetInput, gs as StorageOf, hc as dialectMismatchDiagnostic, hi as ForeignKeyTarget, hs as StorageDialectOf, ia as DeclaredColumnNullability, ic as externalGeneratedColumn, ii as CatalogCheckSql, is as ColumnUpdateInput, ji as catalogForeignKey, jr as SchemaExpressionInput, js as portableStorage, jt as SourceSqlTypes, ki as UniqueNullSemantics, kr as SchemaExpressionError, ks as nullable, kt as SourceRow, lc as SchemaDialectName, li as ConstraintTiming, ls as PortableColumnStorage, mc as assertSchemaDialectSupport, mi as ForeignKeyOptions, ms as StorageDescriptor, na as index, nc as canonicalLiteral, ni as AnyKeyColumn, ns as ColumnStorageType, oc as identityColumn, oi as CheckConstraintOptions, os as NativeColumnStorage, pc as SchemaObjectNameOptions, pi as ForeignKeyMatch, ps as StorageDeclarationOf, qi as IndexDialectExtension, qo as ColumnOptions, qr as SchemaTableEntry, qs as GeneratedDescriptor, qt as TableUpdateInput, ra as validateIndexDialect, rc as externalDefault, ri as CatalogCheckExpression, rs as ColumnStorageTypeOf, sc as resolveColumnBehavior, si as ConstraintDialectExtension, ss as NativeStorage, ta as TableIndex, tc as SqliteIdentityExtension, ti as schemaNamingPolicyVersion, ts as ColumnStorageOf, uc as SchemaMetadataDiagnostic, ui as FieldLike, us as PortableStorage, vc as isValidSchemaObjectName, vi as KeyConstraintOptions, vs as bigint, vt as CustomSource, wi as SourceLike, ws as encodeColumnParameter, wt as SourceConfig, xi as ReferentialAction, xs as column, xt as ProvidedSourceRow, yc as materializeSchemaObjectIdentity, yi as MysqlConstraintExtension, ys as binary, yt as CustomSourceOptions, zi as AliasIdentity, zo as ColumnGeneratedOf, zr as renderSchemaExpression, zs as ColumnDefaultInput, zt as TableColumns } from "./types-C0VkiwpR.mjs";
+import { $i as IndexOptions, $o as ColumnOutput, $r as SchemaTableNames, $s as IdentityDescriptor, Ai as SqliteConstraintExtension, Ar as SchemaDialect, As as integer, At as SourceSqlTypeMap, Bi as references, Bo as ColumnDefaultOf, Br as UnsafeSchemaSqlExpression, Bs as CanonicalLiteral, Bt as TableDefinitions, Cc as isValidSchemaObjectName, Ci as KeyConstraintOptions, Cs as bigint, Ct as SourceColumns, Di as SourceConstraint, Ds as columnResultValue, Dt as SourceKind, Ei as ReferentialAction, Es as column, Et as SourceIdentity, Fi as catalogCheck, Fr as SchemaExpressionErrorCode, Fs as numeric, Ft as exposeColumns, Gi as AliasedSource, Go as ColumnHasDefault, Gr as renderSchemaSql, Gs as DefaultDescriptor, Gt as TableRow, Hi as uniqueConstraint, Ho as ColumnDefinitionConfig, Hr as isUnsafeSchemaSql, Hs as ColumnBehaviorErrorCode, Ht as TableInsertInput, Ii as catalogForeignKey, Ir as SchemaExpressionInput, Is as portableStorage, It as sourceIdentity, Ji as QueryAliasIdentity, Jo as ColumnInsertInput, Jr as Schema, Js as ExternalDefaultDescriptor, Jt as table, Ki as LateralIdentity, Ko as ColumnHasRuntimeDefault, Kr as schemaExpression, Ks as ExpressionDefaultDescriptor, Kt as TableSqlTypes, Li as check, Lr as SchemaExpressionMode, Ls as text, Lt as AnyTable, Mi as UniqueConstraint, Mr as createSchemaDialect, Ms as nativeColumn, Mt as UnknownSourceSqlTypes, Ni as UniqueConstraintOptions, Nr as RenderedSchemaExpression, Ns as nativeStorage, Nt as createSource, Oi as SourceConstraintsRecord, Os as date, Ot as SourceProvision, Pi as UniqueNullSemantics, Pr as SchemaExpressionError, Ps as nullable, Pt as customSource, Qi as IndexDialectExtension, Qo as ColumnOptions, Qr as SchemaTableEntry, Qs as GeneratedDescriptor, Ri as foreignKey, Rr as SchemaRenderContext, Rs as timestamp, Rt as Table, Sc as generatedSchemaObjectName, Si as KeyConstraint, Ss as StorageTypeOf, St as Source, Tc as materializeSchemaObjectRecord, Ti as PostgresConstraintExtension, Ts as boolean, Tt as SourceConstraints, Ui as validateConstraintDialect, Uo as ColumnFromOptions, Ur as normalizeSchemaSql, Us as ColumnDefault, Ut as TableMetadataCallback, Vi as unique, Vo as ColumnDefinition, Vr as defineSchemaExpression, Vs as ColumnBehaviorError, Vt as TableIdentity, Wi as AliasIdentity, Wo as ColumnGeneratedOf, Wr as renderSchemaExpression, Ws as ColumnDefaultInput, Wt as TableOptions, Xi as alias, Xo as ColumnIsNullable, Xr as SchemaNamingPolicy, Xs as GeneratedColumnDescriptor, Yi as QuerySource, Yo as ColumnIsGenerated, Yr as SchemaDiagnostic, Ys as ExternalGeneratedColumnDescriptor, Zi as lateral, Zo as ColumnOnUpdateOf, Zr as SchemaOptions, Zs as GeneratedColumnMode, _c as SchemaObjectIdentity, _i as ForeignKeyConstraint, _s as PortableStorageType, _t as AnySource, aa as SqliteIndexExtension, ac as SchemaLiteralValue, ai as schema, as as ColumnStorageKindOf, bc as dialectMismatchDiagnostic, bi as ForeignKeyTarget, bs as StorageDialectOf, bt as ProvidedSourceIdentity, ca as validateIndexDialect, cc as externalDefault, ci as CatalogCheckExpression, cs as ColumnStorageTypeOf, dc as identityColumn, di as CheckConstraintOptions, ds as NativeColumnStorage, ea as IndexTerm, ec as IdentityDialectExtension, ei as SchemaTableRecord, es as ColumnSqlType, fc as resolveColumnBehavior, fi as ConstraintDialectExtension, fs as NativeStorage, gc as SchemaMetadataValidationError, gi as FieldLikeOptions, gs as PortableStorageDescriptor, hc as SchemaMetadataDiagnostic, hi as FieldLike, hs as PortableStorage, ia as SourceIndexesRecord, ic as ResolvedColumnBehavior, ii as generatedTableName, is as ColumnStorageDialectOf, ji as TableLike, jr as SchemaDialectHooks, js as json, jt as SourceSqlTypes, ki as SourceLike, ks as encodeColumnParameter, kt as SourceRow, la as DeclaredColumnNullability, lc as externalGeneratedColumn, li as CatalogCheckSql, ls as ColumnUpdateInput, mc as SchemaDialectName, mi as ConstraintTiming, ms as PortableColumnStorage, na as PostgresIndexExtension, nc as LiteralDefaultDescriptor, ni as SchemaValidationError, ns as ColumnStorageDeclarationOf, oa as TableIndex, oc as SqliteIdentityExtension, oi as schemaNamingPolicyVersion, os as ColumnStorageOf, pc as SchemaDialectExtension, pi as ConstraintOptions, ps as NativeStorageDescriptor, qi as LateralSource, qo as ColumnIdentityOf, qr as unsafeSchemaSql, qs as ExpressionGeneratedColumnDescriptor, qt as TableUpdateInput, ra as SourceIndex, rc as MysqlIdentityExtension, ri as defaultSchemaNamingPolicy, rs as ColumnStorageDescriptor, sa as index, sc as canonicalLiteral, si as AnyKeyColumn, ss as ColumnStorageType, ta as MysqlIndexExtension, tc as IdentityGeneration, ti as SchemaTableRegistry, ts as ColumnStorage, uc as generatedColumn, ui as CheckConstraint, us as DialectNativeStorage, vc as SchemaObjectNameOptions, vi as ForeignKeyMatch, vs as StorageDeclarationOf, vt as CustomSource, wc as materializeSchemaObjectIdentity, wi as MysqlConstraintExtension, ws as binary, wt as SourceConfig, xc as freezeSchemaMetadata, xi as ForeignKeyTargetInput, xs as StorageOf, xt as ProvidedSourceRow, yc as assertSchemaDialectSupport, yi as ForeignKeyOptions, ys as StorageDescriptor, yt as CustomSourceOptions, zi as primaryKey, zo as ColumnCodec, zr as SchemaRenderOptions, zs as uuid, zt as TableColumns } from "./types-DUe6eeI0.mjs";
 export { AliasIdentity, AliasedSource, AnyKeyColumn, AnySource, AnyTable, CanonicalLiteral, CatalogCheckExpression, CatalogCheckSql, CheckConstraint, CheckConstraintOptions, ColumnBehaviorError, ColumnBehaviorErrorCode, ColumnCodec, ColumnDefault, ColumnDefaultInput, ColumnDefaultOf, ColumnDefinition, ColumnDefinitionConfig, ColumnFromOptions, ColumnGeneratedOf, ColumnHasDefault, ColumnHasRuntimeDefault, ColumnIdentityOf, ColumnInsertInput, ColumnIsGenerated, ColumnIsNullable, ColumnOnUpdateOf, ColumnOptions, ColumnOutput, ColumnSqlType, ColumnStorage, ColumnStorageDeclarationOf, ColumnStorageDescriptor, ColumnStorageDialectOf, ColumnStorageKindOf, ColumnStorageOf, ColumnStorageType, ColumnStorageTypeOf, ColumnUpdateInput, ConstraintDialectExtension, ConstraintOptions, ConstraintTiming, CustomSource, CustomSourceOptions, type DeclaredColumnNullability, DefaultDescriptor, DialectNativeStorage, ExpressionDefaultDescriptor, ExpressionGeneratedColumnDescriptor, ExternalDefaultDescriptor, ExternalGeneratedColumnDescriptor, FieldLike, FieldLikeOptions, ForeignKeyConstraint, ForeignKeyMatch, ForeignKeyOptions, ForeignKeyTarget, ForeignKeyTargetInput, GeneratedColumnDescriptor, GeneratedColumnMode, GeneratedDescriptor, IdentityDescriptor, IdentityDialectExtension, IdentityGeneration, IndexDialectExtension, IndexOptions, IndexTerm, KeyConstraint, KeyConstraintOptions, LateralIdentity, LateralSource, LiteralDefaultDescriptor, MysqlConstraintExtension, MysqlIdentityExtension, MysqlIndexExtension, NativeColumnStorage, NativeStorage, NativeStorageDescriptor, PortableColumnStorage, PortableStorage, PortableStorageDescriptor, PortableStorageType, PostgresConstraintExtension, PostgresIndexExtension, ProvidedSourceIdentity, ProvidedSourceRow, QueryAliasIdentity, QuerySource, ReferentialAction, RenderedSchemaExpression, ResolvedColumnBehavior, Schema, SchemaDiagnostic, SchemaDialect, SchemaDialectExtension, SchemaDialectHooks, SchemaDialectName, SchemaExpressionError, SchemaExpressionErrorCode, SchemaExpressionInput, SchemaExpressionMode, SchemaLiteralValue, SchemaMetadataDiagnostic, SchemaMetadataValidationError, SchemaNamingPolicy, SchemaObjectIdentity, SchemaObjectNameOptions, SchemaOptions, SchemaRenderContext, SchemaRenderOptions, SchemaTableEntry, SchemaTableNames, SchemaTableRecord, SchemaTableRegistry, SchemaValidationError, Source, SourceColumns, SourceConfig, SourceConstraint, SourceConstraints, SourceConstraintsRecord, SourceIdentity, SourceIndex, SourceIndexesRecord, SourceKind, SourceLike, SourceProvision, SourceRow, SourceSqlTypeMap, SourceSqlTypes, SqliteConstraintExtension, SqliteIdentityExtension, SqliteIndexExtension, StorageDeclarationOf, StorageDescriptor, StorageDialectOf, StorageOf, StorageTypeOf, Table, TableColumns, TableDefinitions, TableIdentity, TableIndex, TableInsertInput, TableLike, TableMetadataCallback, TableOptions, TableRow, TableSqlTypes, TableUpdateInput, UniqueConstraint, UniqueConstraintOptions, UniqueNullSemantics, UnknownSourceSqlTypes, UnsafeSchemaSqlExpression, 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 };

package/dist/schema.mjs

@@ -1,8 +1,9 @@
-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 { _ as materializeSchemaObjectIdentity, d as SchemaMetadataValidationError, f as assertSchemaDialectSupport, g as isValidSchemaObjectName, h as generatedSchemaObjectName, m as freezeSchemaMetadata, p as dialectMismatchDiagnostic, v as materializeSchemaObjectRecord } from "./column-BzN8KFJa.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-CFvSbil0.mjs";
+import { i as sourceIdentity, n as customSource, r as exposeColumns, t as createSource } from "./source-BDuUXmAk.mjs";
+import { n as alias, r as lateral, t as table } from "./table-C1QGNe4P.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-DM_tarXc.mjs";
+import { a as renderSchemaExpression, c as unsafeSchemaSql, i as normalizeSchemaSql, n as defineSchemaExpression, o as renderSchemaSql, r as isUnsafeSchemaSql, s as schemaExpression, t as SchemaExpressionError } from "./expressions-BCjc08zw.mjs";
+import { a as schemaNamingPolicyVersion, i as schema, n as defaultSchemaNamingPolicy, r as generatedTableName, t as SchemaValidationError } from "./registry-oWDiqD7i.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 };

package/dist/{serialize-BN07IK0v.mjs → serialize-CE-gw5_s.mjs}

@@ -1,6 +1,6 @@
-import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
-import { r as isColumnReference, u as generatedSchemaObjectName } from "./column-r1Y4ivwt.mjs";
-import { c as isUnsafeSchemaSql, n as defaultSchemaNamingPolicy, u as renderSchemaExpression } from "./registry-BRcUuazJ.mjs";
+import { H as standardDialect, h as generatedSchemaObjectName, r as isColumnReference } from "./column-BzN8KFJa.mjs";
+import { a as renderSchemaExpression, r as isUnsafeSchemaSql } from "./expressions-BCjc08zw.mjs";
+import { n as defaultSchemaNamingPolicy } from "./registry-oWDiqD7i.mjs";
 import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
 import { a as toSnapshotJsonValue, f as schemaSnapshotFormat, i as schemaSnapshotFingerprint, o as SnapshotValidationError, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, u as neutralSnapshotDialect } from "./canonical-DMvR9yBe.mjs";
 //#region src/snapshot/serialize.ts

package/dist/{serialize-CEIIlWhC.d.mts → serialize-OvXCLzjm.d.mts}

@@ -1,4 +1,4 @@
-import { T as SnapshotJsonValue, Tr as SchemaDialect, Ur as Schema, f as SnapshotDiagnostic, i as SchemaSnapshotInput, l as SnapshotCreateResult, n as SchemaSnapshot, r as SchemaSnapshotAdapter, u as SnapshotDecodeResult } from "./types-C0VkiwpR.mjs";
+import { Ar as SchemaDialect, Jr as Schema, T as SnapshotJsonValue, f as SnapshotDiagnostic, i as SchemaSnapshotInput, l as SnapshotCreateResult, n as SchemaSnapshot, r as SchemaSnapshotAdapter, u as SnapshotDecodeResult } from "./types-DUe6eeI0.mjs";
 //#region src/snapshot/canonical.d.ts
 /** Error raised when a value cannot cross the canonical JSON boundary. */
 declare class SnapshotCanonicalError extends TypeError {

package/dist/snapshot/mysql.d.mts

@@ -1,5 +1,5 @@
-import { Tr as SchemaDialect, Ur as Schema, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter } from "../types-C0VkiwpR.mjs";
-import { t as SchemaSnapshotOptions } from "../serialize-CEIIlWhC.mjs";
+import { Ar as SchemaDialect, Jr as Schema, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter } from "../types-DUe6eeI0.mjs";
+import { t as SchemaSnapshotOptions } from "../serialize-OvXCLzjm.mjs";
 //#region src/snapshot/mysql.d.ts
 /** MySQL's v1 snapshot extension identity. */
 declare const mysqlSnapshotDialect: SnapshotDialect;