qubu 0.4.0 → 0.4.2

package/dist/drizzle-mysql.mjs

@@ -1,72 +0,0 @@
-import { t as createMysqlSchemaSnapshot } from "./mysql-CKEKGnj4.mjs";
-import { i as stringExtension, n as extensionData, t as convertDrizzleSchema } from "./runtime-Cn_Xgzta.mjs";
-import { bigint, boolean, char, check, customType, date, datetime, decimal, foreignKey, index, int, json, mysqlSchema, mysqlTable, primaryKey, text, unique, uniqueIndex } from "drizzle-orm/mysql-core";
-//#region src/drizzle/mysql.ts
-const mysqlAdapter = {
-	dialect: "mysql",
-	createSnapshot: createMysqlSchemaSnapshot,
-	createTableFactory(namespace) {
-		return namespace === void 0 ? mysqlTable : mysqlSchema(namespace).table;
-	},
-	createStorageBuilder: createMysqlStorageBuilder,
-	applyIdentity(builder, definition) {
-		const extension = definition.identity?.dialect;
-		return extension?.dialect === "mysql" && "autoIncrement" in extension && extension.autoIncrement === true && builder.autoincrement ? builder.autoincrement() : builder;
-	},
-	createPrimaryKey(name, columns) {
-		return primaryKey({
-			name,
-			columns
-		});
-	},
-	createUniqueConstraint(name, columns) {
-		return unique(name).on(...columns);
-	},
-	createCheck: check,
-	createForeignKey(name, columns, foreignColumns) {
-		return foreignKey({
-			name,
-			columns,
-			foreignColumns
-		});
-	},
-	createIndex(indexDefinition, terms) {
-		const data = extensionData(indexDefinition.dialect);
-		let builder = (indexDefinition.unique ? uniqueIndex(indexDefinition.physicalName) : index(indexDefinition.physicalName)).on(...terms);
-		const using = stringExtension(data, "using");
-		const algorithm = stringExtension(data, "algorithm");
-		const lock = stringExtension(data, "lock");
-		if (using) builder = builder.using(using);
-		if (algorithm) builder = builder.algorithm(algorithm);
-		if (lock) builder = builder.lock(lock);
-		return builder;
-	}
-};
-/**
-* Convert a live Qubu schema registry into MySQL Drizzle table objects.
-*
-* @throws A snapshot validation error for invalid MySQL metadata, or a
-* DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
-*/
-function toMysqlDrizzleSchema(schema) {
-	return convertDrizzleSchema(schema, mysqlAdapter);
-}
-function createMysqlStorageBuilder(type, name, declaration) {
-	return (() => {
-		switch (type) {
-			case "integer": return int(name);
-			case "numeric": return decimal(name, { mode: "number" });
-			case "text": return text(name);
-			case "boolean": return boolean(name);
-			case "date": return date(name, { mode: "date" });
-			case "timestamp": return datetime(name, { mode: "date" });
-			case "uuid": return char(name, { length: 36 });
-			case "json": return json(name);
-			case "bigint": return bigint(name, { mode: "bigint" });
-			case "binary": return customType({ dataType: () => declaration })(name);
-			default: return customType({ dataType: () => declaration })(name);
-		}
-	})();
-}
-//#endregion
-export { toMysqlDrizzleSchema };

package/dist/drizzle-postgres.d.mts

@@ -1,24 +0,0 @@
-import { Lt as AnyTable, ei as Schema, oi as SchemaTableRecord } from "./types-Deo_q43Y.mjs";
-import { r as DrizzleSchemaValidation, t as DrizzleColumnConfig } from "./types-DZsueVoI.mjs";
-import { PgColumn, PgTableWithColumns } from "drizzle-orm/pg-core";
-//#region src/drizzle/postgres.d.ts
-type PostgresDrizzleColumn<TTableName extends string, TDefinition> = PgColumn<'custom', DrizzleColumnConfig<TTableName, TDefinition>>;
-type PostgresDrizzleColumns<TTable extends AnyTable> = { [TKey in keyof TTable['definitions']]: PostgresDrizzleColumn<TTable['tableName'], TTable['definitions'][TKey]>; };
-/** The Drizzle PostgreSQL table produced for one Qubu table. */
-type PostgresDrizzleTable<TTable extends AnyTable> = PgTableWithColumns<{
-  name: TTable['tableName'];
-  schema: string | undefined;
-  columns: PostgresDrizzleColumns<TTable>;
-  dialect: 'pg';
-}>;
-/** A PostgreSQL Drizzle table record retaining Qubu's logical table keys. */
-type PostgresDrizzleSchema<TSchema extends Schema<any>> = { readonly [TKey in keyof TSchema['tables']]: PostgresDrizzleTable<TSchema['tables'][TKey]>; };
-/**
- * Convert a live Qubu schema registry into PostgreSQL Drizzle table objects.
- *
- * @throws A snapshot validation error for invalid PostgreSQL metadata, or a
- * DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
- */
-declare function toPostgresDrizzleSchema<const TTables extends SchemaTableRecord>(schema: Schema<TTables> & DrizzleSchemaValidation<TTables, 'postgresql'>): PostgresDrizzleSchema<Schema<TTables>>;
-//#endregion
-export { PostgresDrizzleSchema, PostgresDrizzleTable, toPostgresDrizzleSchema };

package/dist/drizzle-postgres.mjs

@@ -1,73 +0,0 @@
-import { t as createPostgresSchemaSnapshot } from "./postgres-BK2APkKP.mjs";
-import { i as stringExtension, n as extensionData, r as recordExtension, t as convertDrizzleSchema } from "./runtime-Cn_Xgzta.mjs";
-import { bigint, boolean, check, customType, date, foreignKey, index, integer, jsonb, numeric, pgSchema, pgTable, primaryKey, text, timestamp, unique, uniqueIndex, uuid } from "drizzle-orm/pg-core";
-//#region src/drizzle/postgres.ts
-const postgresAdapter = {
-	dialect: "postgresql",
-	createSnapshot: createPostgresSchemaSnapshot,
-	createTableFactory(namespace) {
-		return namespace === void 0 ? pgTable : pgSchema(namespace).table;
-	},
-	createStorageBuilder: createPostgresStorageBuilder,
-	applyIdentity(builder, _definition, column) {
-		const method = column.identity?.generation === "always" ? builder.generatedAlwaysAsIdentity : builder.generatedByDefaultAsIdentity;
-		return method === void 0 ? builder : method.call(builder);
-	},
-	createPrimaryKey(name, columns) {
-		return primaryKey({
-			name,
-			columns
-		});
-	},
-	createUniqueConstraint(name, columns, nullsNotDistinct) {
-		const builder = unique(name).on(...columns);
-		return nullsNotDistinct ? builder.nullsNotDistinct() : builder;
-	},
-	createCheck: check,
-	createForeignKey(name, columns, foreignColumns) {
-		return foreignKey({
-			name,
-			columns,
-			foreignColumns
-		});
-	},
-	createIndex(indexDefinition, terms, predicate) {
-		const data = extensionData(indexDefinition.dialect);
-		const start = indexDefinition.unique ? uniqueIndex(indexDefinition.physicalName) : index(indexDefinition.physicalName);
-		const method = stringExtension(data, "method");
-		let builder = method ? start.using(method, ...terms) : start.on(...terms);
-		if (data.concurrently === true) builder = builder.concurrently();
-		const storageParameters = recordExtension(data, "storageParameters");
-		if (storageParameters) builder = builder.with(storageParameters);
-		if (predicate) builder = builder.where(predicate);
-		return builder;
-	}
-};
-/**
-* Convert a live Qubu schema registry into PostgreSQL Drizzle table objects.
-*
-* @throws A snapshot validation error for invalid PostgreSQL metadata, or a
-* DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
-*/
-function toPostgresDrizzleSchema(schema) {
-	return convertDrizzleSchema(schema, postgresAdapter);
-}
-function createPostgresStorageBuilder(type, name, declaration) {
-	return (() => {
-		switch (type) {
-			case "integer": return integer(name);
-			case "numeric": return numeric(name, { mode: "number" });
-			case "text": return text(name);
-			case "boolean": return boolean(name);
-			case "date": return date(name, { mode: "date" });
-			case "timestamp": return timestamp(name, { mode: "date" });
-			case "uuid": return uuid(name);
-			case "json": return jsonb(name);
-			case "bigint": return bigint(name, { mode: "bigint" });
-			case "binary": return customType({ dataType: () => declaration })(name);
-			default: return customType({ dataType: () => declaration })(name);
-		}
-	})();
-}
-//#endregion
-export { toPostgresDrizzleSchema };

package/dist/drizzle-sqlite.d.mts

@@ -1,57 +0,0 @@
-import { Lt as AnyTable, Uu as SqlTimestamp, ei as Schema, kc as ExternalDefaultDescriptor, oi as SchemaTableRecord, qs as NativeColumnStorage, ws as ColumnDefinition } from "./types-Deo_q43Y.mjs";
-import { r as DrizzleSchemaValidation, t as DrizzleColumnConfig } from "./types-DZsueVoI.mjs";
-import { SQLiteColumn, SQLiteTableWithColumns } from "drizzle-orm/sqlite-core";
-//#region src/drizzle/sqlite.d.ts
-type SqliteDrizzleColumn<TTableName extends string, TDefinition> = SQLiteColumn<DrizzleColumnConfig<TTableName, TDefinition>>;
-type SqliteDrizzleColumns<TTable extends AnyTable> = { [TKey in keyof TTable['definitions']]: SqliteDrizzleColumn<TTable['tableName'], TTable['definitions'][TKey]>; };
-/** Integer encoding used by Drizzle's SQLite timestamp column builder. */
-type SqliteTimestampMode = 'timestamp' | 'timestamp_ms';
-/** Runtime options for a Drizzle-compatible SQLite integer timestamp. */
-interface SqliteTimestampOptions {
-  /** Store Unix seconds by default, or milliseconds with `timestamp_ms`. */
-  readonly mode?: SqliteTimestampMode;
-  readonly nullable?: boolean;
-  readonly sqlName?: string;
-  /** Supply an application value when a Drizzle insert omits this column. */
-  readonly defaultFn?: () => Date;
-}
-type SqliteTimestampNullable<TOptions extends SqliteTimestampOptions> = TOptions extends {
-  readonly nullable: true;
-} ? true : false;
-type SqliteTimestampHasDefault<TOptions extends SqliteTimestampOptions> = TOptions extends {
-  readonly defaultFn: () => Date;
-} ? true : false;
-/** Qubu definition produced by {@link sqliteTimestamp}. */
-type SqliteTimestampColumn<TOptions extends SqliteTimestampOptions = {}> = ColumnDefinition<{
-  readonly output: Date;
-  readonly nullable: SqliteTimestampNullable<TOptions>;
-  readonly hasDefault: SqliteTimestampHasDefault<TOptions>;
-  readonly sqlType: SqlTimestamp;
-  readonly storage: NativeColumnStorage<'sqlite', 'INTEGER'>;
-  readonly default: SqliteTimestampHasDefault<TOptions> extends true ? ExternalDefaultDescriptor : undefined;
-}>;
-/**
- * Declare a SQLite `INTEGER` timestamp that retains Drizzle's Date codec.
- *
- * @remarks `defaultFn` is runtime-only. Snapshots and emitted DDL retain the
- * native `INTEGER` storage but do not serialize the callback.
- */
-declare function sqliteTimestamp<const TOptions extends SqliteTimestampOptions = {}>(options?: TOptions): SqliteTimestampColumn<TOptions>;
-/** The Drizzle SQLite table produced for one Qubu table. */
-type SqliteDrizzleTable<TTable extends AnyTable> = SQLiteTableWithColumns<{
-  name: TTable['tableName'];
-  schema: undefined;
-  columns: SqliteDrizzleColumns<TTable>;
-  dialect: 'sqlite';
-}>;
-/** A SQLite Drizzle table record retaining Qubu's logical table keys. */
-type SqliteDrizzleSchema<TSchema extends Schema<any>> = { readonly [TKey in keyof TSchema['tables']]: SqliteDrizzleTable<TSchema['tables'][TKey]>; };
-/**
- * Convert a live Qubu schema registry into SQLite Drizzle table objects.
- *
- * @throws A snapshot validation error for invalid SQLite metadata, or a
- * DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
- */
-declare function toSqliteDrizzleSchema<const TTables extends SchemaTableRecord>(schema: Schema<TTables> & DrizzleSchemaValidation<TTables, 'sqlite'>): SqliteDrizzleSchema<Schema<TTables>>;
-//#endregion
-export { SqliteDrizzleSchema, SqliteDrizzleTable, SqliteTimestampColumn, SqliteTimestampMode, SqliteTimestampOptions, sqliteTimestamp, toSqliteDrizzleSchema };

package/dist/drizzle-sqlite.mjs

@@ -1,108 +0,0 @@
-import { l as nativeColumn } from "./column-LV7oGQde.mjs";
-import { t as createSqliteSchemaSnapshot } from "./sqlite-CrsK0Fza.mjs";
-import { t as convertDrizzleSchema } from "./runtime-Cn_Xgzta.mjs";
-import { blob, check, customType, foreignKey, index, integer, primaryKey, sqliteTable, text, unique, uniqueIndex } from "drizzle-orm/sqlite-core";
-//#region src/drizzle/sqlite.ts
-const sqliteTimestampRuntime = /* @__PURE__ */ new WeakMap();
-/**
-* Declare a SQLite `INTEGER` timestamp that retains Drizzle's Date codec.
-*
-* @remarks `defaultFn` is runtime-only. Snapshots and emitted DDL retain the
-* native `INTEGER` storage but do not serialize the callback.
-*/
-function sqliteTimestamp(options) {
-	const definition = nativeColumn("sqlite", "INTEGER", {
-		nullable: options?.nullable === true,
-		hasDefault: options?.defaultFn !== void 0,
-		sqlName: options?.sqlName
-	}).$type();
-	sqliteTimestampRuntime.set(definition, Object.freeze({
-		mode: options?.mode ?? "timestamp",
-		...options?.defaultFn === void 0 ? {} : { defaultFn: options.defaultFn }
-	}));
-	return definition;
-}
-const sqliteAdapter = {
-	dialect: "sqlite",
-	createSnapshot: createSqliteSchemaSnapshot,
-	createTableFactory() {
-		return sqliteTable;
-	},
-	createStorageBuilder: createSqliteStorageBuilder,
-	applyIdentity(builder, definition, column, table) {
-		const extension = definition.identity?.dialect;
-		const autoIncrement = extension?.dialect === "sqlite" && "autoIncrement" in extension && extension.autoIncrement === true;
-		const isSingleColumnPrimaryKey = table.constraints.some((constraint) => constraint.kind === "primary-key" && constraint.columns.length === 1 && constraint.columns[0] === column.id);
-		return autoIncrement && isSingleColumnPrimaryKey && builder.primaryKey ? builder.primaryKey({ autoIncrement: true }) : builder;
-	},
-	createPrimaryKey(name, columns) {
-		return primaryKey({
-			name,
-			columns
-		});
-	},
-	createUniqueConstraint(name, columns) {
-		return unique(name).on(...columns);
-	},
-	createCheck: check,
-	createForeignKey(name, columns, foreignColumns) {
-		return foreignKey({
-			name,
-			columns,
-			foreignColumns
-		});
-	},
-	createIndex(indexDefinition, terms, predicate) {
-		let builder = (indexDefinition.unique ? uniqueIndex(indexDefinition.physicalName) : index(indexDefinition.physicalName)).on(...terms);
-		if (predicate) builder = builder.where(predicate);
-		return builder;
-	}
-};
-/**
-* Convert a live Qubu schema registry into SQLite Drizzle table objects.
-*
-* @throws A snapshot validation error for invalid SQLite metadata, or a
-* DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
-*/
-function toSqliteDrizzleSchema(schema) {
-	return convertDrizzleSchema(schema, sqliteAdapter);
-}
-function createSqliteStorageBuilder(type, name, declaration, definition) {
-	const timestampRuntime = sqliteTimestampRuntime.get(definition);
-	if (timestampRuntime !== void 0) {
-		let builder = integer(name, { mode: timestampRuntime.mode });
-		if (timestampRuntime.defaultFn !== void 0) builder = builder.$defaultFn(timestampRuntime.defaultFn);
-		return builder;
-	}
-	return (() => {
-		switch (type) {
-			case "integer": return integer(name);
-			case "numeric": return customType({
-				dataType: () => declaration,
-				fromDriver: (value) => Number(value)
-			})(name);
-			case "text": return text(name);
-			case "boolean": return integer(name, { mode: "boolean" });
-			case "date": return customType({
-				dataType: () => declaration,
-				fromDriver: (value) => new Date(value),
-				toDriver: (value) => value.toISOString().slice(0, 10)
-			})(name);
-			case "timestamp": return customType({
-				dataType: () => declaration,
-				fromDriver: (value) => new Date(value),
-				toDriver: (value) => value.toISOString()
-			})(name);
-			case "uuid": return text(name);
-			case "json": return text(name, { mode: "json" });
-			case "bigint": return customType({
-				dataType: () => declaration,
-				fromDriver: (value) => BigInt(value)
-			})(name);
-			case "binary": return blob(name, { mode: "buffer" });
-			default: return customType({ dataType: () => declaration })(name);
-		}
-	})();
-}
-//#endregion
-export { sqliteTimestamp, toSqliteDrizzleSchema };

package/dist/drizzle.d.mts

@@ -1,13 +0,0 @@
-import { n as DrizzleDialect } from "./types-DZsueVoI.mjs";
-//#region src/drizzle/errors.d.ts
-/** Stable failure categories raised while building a Drizzle schema. */
-type DrizzleSchemaConversionErrorCode = 'missing-storage' | 'unsupported-metadata';
-/** A path-addressed failure raised when Drizzle cannot represent Qubu metadata. */
-declare class DrizzleSchemaConversionError extends TypeError {
-  readonly name = "DrizzleSchemaConversionError";
-  readonly code: DrizzleSchemaConversionErrorCode;
-  readonly path: readonly (string | number)[];
-  constructor(code: DrizzleSchemaConversionErrorCode, message: string, path: readonly (string | number)[]);
-}
-//#endregion
-export { type DrizzleDialect, DrizzleSchemaConversionError, type DrizzleSchemaConversionErrorCode };

package/dist/drizzle.mjs

@@ -1,2 +0,0 @@
-import { t as DrizzleSchemaConversionError } from "./errors-BGCoLe_r.mjs";
-export { DrizzleSchemaConversionError };

package/dist/errors-BGCoLe_r.mjs

@@ -1,14 +0,0 @@
-//#region src/drizzle/errors.ts
-/** A path-addressed failure raised when Drizzle cannot represent Qubu metadata. */
-var DrizzleSchemaConversionError = class extends TypeError {
-	name = "DrizzleSchemaConversionError";
-	code;
-	path;
-	constructor(code, message, path) {
-		super(message);
-		this.code = code;
-		this.path = Object.freeze([...path]);
-	}
-};
-//#endregion
-export { DrizzleSchemaConversionError as t };

package/dist/postgres-BK2APkKP.mjs

@@ -1,236 +0,0 @@
-import { d as isValidSchemaObjectName } from "./column-D-8OqGuV.mjs";
-import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-CXV8u7Pt.mjs";
-import { t as createSchemaDialect } from "./dialect-b2-Z6uBF.mjs";
-import { a as toSnapshotJsonValue } from "./canonical-BbnqavJm.mjs";
-import { n as createSchemaSnapshot, s as tryCreateSchemaSnapshot } from "./serialize-CFtYYAdk.mjs";
-import { postgresDialect } from "./postgres.mjs";
-//#region src/snapshot/postgres.ts
-/** PostgreSQL's v1 snapshot extension identity. */
-const postgresSnapshotDialect = Object.freeze({
-	name: "postgresql",
-	version: 1
-});
-var PostgresSnapshotDialectError = class extends TypeError {
-	code = "dialect-mismatch";
-};
-const postgresStorageTypes = Object.freeze({
-	integer: "INTEGER",
-	numeric: "NUMERIC",
-	text: "TEXT",
-	boolean: "BOOLEAN",
-	date: "DATE",
-	timestamp: "TIMESTAMP",
-	uuid: "UUID",
-	json: "JSONB",
-	bigint: "BIGINT",
-	binary: "BYTEA"
-});
-/** PostgreSQL's query dialect plus its schema metadata behavior. */
-const postgresSchemaDialect = createSchemaDialect(postgresDialect(), {
-	version: 1,
-	validate: validatePostgresSchema,
-	encodeStorage(storage, context) {
-		return encodePostgresStorage(storage, context.dialect);
-	},
-	encodeExpression(expression, context) {
-		return encodePostgresExpression(expression, context.mode, context.dialect);
-	},
-	encodeDialectExtension(extension, context) {
-		return encodePostgresExtension(extension, context.dialect);
-	}
-});
-/** Snapshot adapter retaining the historical adapter-shaped entry point. */
-const postgresSnapshotAdapter = Object.freeze({ dialect: postgresSchemaDialect });
-/** Create a canonical PostgreSQL schema snapshot. */
-function createPostgresSchemaSnapshot(schema, options = {}) {
-	return createSchemaSnapshot(schema, {
-		...options,
-		adapter: postgresSnapshotAdapter
-	});
-}
-/** Return PostgreSQL capability diagnostics without throwing. */
-function tryCreatePostgresSchemaSnapshot(schema, options = {}) {
-	return tryCreateSchemaSnapshot(schema, {
-		...options,
-		adapter: postgresSnapshotAdapter
-	});
-}
-function encodePostgresStorage(storage, dialect) {
-	if (storage.kind === "native") {
-		if (storage.dialect !== dialect.name) throw new TypeError(`PostgreSQL storage cannot encode a native declaration owned by "${storage.dialect}"`);
-		if (storage.type.trim().length === 0) throw new TypeError("PostgreSQL native storage declarations cannot be empty");
-		return {
-			kind: "native",
-			dialect: dialect.name,
-			type: storage.type
-		};
-	}
-	const type = postgresStorageTypes[storage.type];
-	if (type === void 0) throw new TypeError(`Unsupported portable storage type for PostgreSQL: ${String(storage.type)}`);
-	return {
-		kind: "native",
-		dialect: dialect.name,
-		type
-	};
-}
-function encodePostgresExpression(expression, mode, dialect) {
-	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new PostgresSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the PostgreSQL schema dialect is "${dialect.name}"`);
-	const rendered = renderSchemaExpression(expression, {
-		mode,
-		dialect
-	});
-	if (rendered.parameters.length !== 0) throw new TypeError("PostgreSQL schema expressions must be parameter-free");
-	return {
-		kind: "expression",
-		expressionKind: expression.expressionKind,
-		sql: rendered.text,
-		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
-	};
-}
-function encodePostgresExtension(extension, dialect) {
-	if (extension.dialect !== dialect.name) throw new TypeError(`PostgreSQL schema extensions require dialect "${dialect.name}"`);
-	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
-	return {
-		dialect: dialect.name,
-		version: dialect.schema.version,
-		data: sortSnapshotJson(toSnapshotJsonValue(data))
-	};
-}
-function sortSnapshotJson(value) {
-	if (Array.isArray(value)) return value.map(sortSnapshotJson);
-	if (typeof value !== "object" || value === null) return value;
-	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson(child)]));
-}
-function validatePostgresSchema(schema, context) {
-	const diagnostics = [];
-	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds(left, right));
-	const relationNames = /* @__PURE__ */ new Map();
-	if (schema.namespace !== void 0) validatePostgresName(schema.namespace, ["namespace"], "PostgreSQL namespace", diagnostics);
-	for (const [id, entry] of tableEntries) {
-		const tablePath = ["tables", id];
-		validatePostgresName(entry.physicalName, [...tablePath, "physicalName"], "PostgreSQL table", diagnostics);
-		addRelationName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
-	}
-	for (const [id, entry] of tableEntries) validatePostgresTable(id, entry, context, relationNames, diagnostics);
-	return Object.freeze(diagnostics);
-}
-function validatePostgresTable(tableId, entry, context, relationNames, diagnostics) {
-	const table = entry.table;
-	const tablePath = ["tables", tableId];
-	const definitions = table.definitions;
-	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds(left, right))) {
-		validatePostgresName(table.sqlNames[columnId] ?? columnId, [
-			...tablePath,
-			"columns",
-			columnId,
-			"physicalName"
-		], "PostgreSQL column", diagnostics);
-		if (definition.onUpdate !== void 0) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL ON UPDATE expressions are not supported by PostgreSQL",
-			path: [
-				...tablePath,
-				"columns",
-				columnId,
-				"onUpdate"
-			]
-		});
-		const generated = definition.generatedColumn;
-		if (generated !== void 0 && generated.kind === "expression" && generated.mode === "virtual") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "PostgreSQL v1 snapshots support stored generated columns only; virtual generated columns are not supported",
-			path: [
-				...tablePath,
-				"columns",
-				columnId,
-				"generatedColumn",
-				"mode"
-			]
-		});
-	}
-	const metadata = table;
-	const constraintNames = /* @__PURE__ */ new Map();
-	const constraints = Object.entries(metadata.constraints);
-	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds(left, right))) {
-		const constraintPath = [
-			...tablePath,
-			"constraints",
-			constraintId
-		];
-		const physicalName = constraint.physicalName ?? constraintId;
-		validatePostgresName(physicalName, [...constraintPath, "physicalName"], "PostgreSQL constraint", diagnostics);
-		addScopedName(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
-		appendMetadataDiagnostics(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
-		if (constraint.kind === "check" && constraint.deferrable === true) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "PostgreSQL CHECK constraints cannot be DEFERRABLE",
-			path: [...constraintPath, "deferrable"]
-		});
-		if (constraint.kind === "foreign-key" && constraint.match === "partial") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "PostgreSQL does not implement MATCH PARTIAL foreign keys",
-			path: [...constraintPath, "match"]
-		});
-		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "PostgreSQL NULLS NOT DISTINCT requires a server-version policy; the v1 adapter does not assume PostgreSQL 15 or newer",
-			path: [...constraintPath, "nulls"]
-		});
-	}
-	const indexes = Object.entries(metadata.indexes);
-	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds(left, right))) {
-		const indexPath = [
-			...tablePath,
-			"indexes",
-			indexId
-		];
-		const physicalName = index.physicalName ?? indexId;
-		validatePostgresName(physicalName, [...indexPath, "physicalName"], "PostgreSQL index", diagnostics);
-		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
-		appendMetadataDiagnostics(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
-	}
-}
-function validatePostgresName(name, path, kind, diagnostics) {
-	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
-		code: "invalid-schema",
-		message: `${kind} name "${name}" is not a valid unqualified identifier`,
-		path
-	});
-	if (new TextEncoder().encode(name).length > 63) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: `${kind} name exceeds PostgreSQL's 63-byte identifier limit`,
-		path
-	});
-}
-function addRelationName(names, name, path, kind, diagnostics) {
-	addScopedName(names, name, path, kind, diagnostics);
-}
-function addScopedName(names, name, path, kind, diagnostics) {
-	const previousPath = names.get(name);
-	if (previousPath !== void 0) {
-		diagnostics.push({
-			code: "invalid-schema",
-			message: `PostgreSQL ${kind} name "${name}" collides with another relation or metadata object`,
-			path,
-			relatedPaths: [previousPath]
-		});
-		return;
-	}
-	names.set(name, path);
-}
-function appendMetadataDiagnostics(diagnostics, issues) {
-	for (const issue of issues) {
-		if (issue.code === "dialect-mismatch") continue;
-		diagnostics.push({
-			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
-			message: issue.message,
-			path: issue.path,
-			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
-		});
-	}
-}
-function compareIds(left, right) {
-	return left < right ? -1 : left > right ? 1 : 0;
-}
-//#endregion
-export { tryCreatePostgresSchemaSnapshot as a, postgresSnapshotDialect as i, postgresSchemaDialect as n, postgresSnapshotAdapter as r, createPostgresSchemaSnapshot as t };