@fragno-dev/db 0.2.2 → 0.3.0

package/dist/schema/type-conversion/create-sql-type-mapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-sql-type-mapper.js","names":["exhaustiveCheck: never"],"sources":["../../../src/schema/type-conversion/create-sql-type-mapper.ts"],"sourcesContent":["import type { SupportedDatabase } from \"../../adapters/generic-sql/driver-config\";\nimport { PostgreSQLTypeMapper } from \"./dialect/postgres\";\nimport { MySQLTypeMapper } from \"./dialect/mysql\";\nimport { SQLiteTypeMapper } from \"./dialect/sqlite\";\n\n/**\n * Factory function to create a dialect-specific SQL type mapper.\n *\n * Based on the database type, returns the appropriate mapper implementation\n * (PostgreSQL, MySQL, or SQLite).\n *\n * @param database - The database type (sqlite, postgresql, or mysql)\n * @returns Dialect-specific SQLTypeMapper instance\n */\nexport function createSQLTypeMapper(database: SupportedDatabase) {\n  switch (database) {\n    case \"postgresql\":\n      return new PostgreSQLTypeMapper(database);\n    case \"mysql\":\n      return new MySQLTypeMapper(database);\n    case \"sqlite\":\n      return new SQLiteTypeMapper(database);\n    default: {\n      const exhaustiveCheck: never = database;\n      throw new Error(`Unsupported database type: ${exhaustiveCheck}`);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,oBAAoB,UAA6B;AAC/D,SAAQ,UAAR;EACE,KAAK,aACH,QAAO,IAAI,qBAAqB,SAAS;EAC3C,KAAK,QACH,QAAO,IAAI,gBAAgB,SAAS;EACtC,KAAK,SACH,QAAO,IAAI,iBAAiB,SAAS;EACvC,SAAS;GACP,MAAMA,kBAAyB;AAC/B,SAAM,IAAI,MAAM,8BAA8B,kBAAkB"}
+{"version":3,"file":"create-sql-type-mapper.js","names":["exhaustiveCheck: never"],"sources":["../../../src/schema/type-conversion/create-sql-type-mapper.ts"],"sourcesContent":["import type { SupportedDatabase } from \"../../adapters/generic-sql/driver-config\";\nimport type { SQLiteStorageMode } from \"../../adapters/generic-sql/sqlite-storage\";\nimport { PostgreSQLTypeMapper } from \"./dialect/postgres\";\nimport { MySQLTypeMapper } from \"./dialect/mysql\";\nimport { SQLiteTypeMapper } from \"./dialect/sqlite\";\n\n/**\n * Factory function to create a dialect-specific SQL type mapper.\n *\n * Based on the database type, returns the appropriate mapper implementation\n * (PostgreSQL, MySQL, or SQLite).\n *\n * @param database - The database type (sqlite, postgresql, or mysql)\n * @param sqliteStorageMode - Optional SQLite storage mode override\n * @returns Dialect-specific SQLTypeMapper instance\n */\nexport function createSQLTypeMapper(\n  database: SupportedDatabase,\n  sqliteStorageMode?: SQLiteStorageMode,\n) {\n  switch (database) {\n    case \"postgresql\":\n      return new PostgreSQLTypeMapper(database);\n    case \"mysql\":\n      return new MySQLTypeMapper(database);\n    case \"sqlite\":\n      return new SQLiteTypeMapper(database, sqliteStorageMode);\n    default: {\n      const exhaustiveCheck: never = database;\n      throw new Error(`Unsupported database type: ${exhaustiveCheck}`);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,SAAgB,oBACd,UACA,mBACA;AACA,SAAQ,UAAR;EACE,KAAK,aACH,QAAO,IAAI,qBAAqB,SAAS;EAC3C,KAAK,QACH,QAAO,IAAI,gBAAgB,SAAS;EACtC,KAAK,SACH,QAAO,IAAI,iBAAiB,UAAU,kBAAkB;EAC1D,SAAS;GACP,MAAMA,kBAAyB;AAC/B,SAAM,IAAI,MAAM,8BAA8B,kBAAkB"}

package/dist/schema/type-conversion/dialect/sqlite.js

@@ -1,3 +1,4 @@
+import { sqliteStorageDefault } from "../../../adapters/generic-sql/sqlite-storage.js";
 import { SQLTypeMapper } from "../type-mapping.js";
 
 //#region src/schema/type-conversion/dialect/sqlite.ts
@@ -11,6 +12,11 @@ import { SQLTypeMapper } from "../type-mapping.js";
 * - REAL for decimals
 */
 var SQLiteTypeMapper = class extends SQLTypeMapper {
+	sqliteStorageMode;
+	constructor(database, sqliteStorageMode) {
+		super(database);
+		this.sqliteStorageMode = sqliteStorageMode ?? sqliteStorageDefault;
+	}
 	getInternalIdType() {
 		return "integer";
 	}
@@ -19,6 +25,7 @@ var SQLiteTypeMapper = class extends SQLTypeMapper {
 	}
 	mapBigint(column) {
 		if ("role" in column && column.role === "reference") return "integer";
+		if (this.sqliteStorageMode.bigintStorage === "integer") return "integer";
 		return "blob";
 	}
 	mapString() {
@@ -37,9 +44,11 @@ var SQLiteTypeMapper = class extends SQLTypeMapper {
 		return "real";
 	}
 	mapTimestamp() {
+		if (this.sqliteStorageMode.timestampStorage === "iso-text") return "text";
 		return "integer";
 	}
 	mapDate() {
+		if (this.sqliteStorageMode.dateStorage === "iso-text") return "text";
 		return "integer";
 	}
 	mapJson() {

package/dist/schema/type-conversion/dialect/sqlite.js.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite.js","names":[],"sources":["../../../../src/schema/type-conversion/dialect/sqlite.ts"],"sourcesContent":["import type { AnyColumn } from \"../../create\";\nimport { SQLTypeMapper, type SQLiteDatabaseType } from \"../type-mapping\";\n\n/**\n * SQLite-specific type mapper.\n *\n * SQLite has a limited type system with only 4 storage classes:\n * - INTEGER for integers, booleans, timestamps, dates (and reference columns)\n * - BLOB for binary data and bigints (except for reference columns)\n * - TEXT for strings, JSON, and varchar\n * - REAL for decimals\n */\nexport class SQLiteTypeMapper extends SQLTypeMapper<SQLiteDatabaseType> {\n  protected getInternalIdType(): SQLiteDatabaseType {\n    // SQLite uses INTEGER for auto-increment (INTEGER PRIMARY KEY)\n    return \"integer\";\n  }\n\n  protected mapInteger(_column: AnyColumn | Pick<AnyColumn, \"type\">): SQLiteDatabaseType {\n    return \"integer\";\n  }\n\n  protected mapBigint(column: AnyColumn | Pick<AnyColumn, \"type\">): SQLiteDatabaseType {\n    // SQLite special case: reference columns should use integer even if type is bigint\n    if (\"role\" in column && column.role === \"reference\") {\n      return \"integer\";\n    }\n    return \"blob\";\n  }\n\n  protected mapString(): SQLiteDatabaseType {\n    return \"text\";\n  }\n\n  protected mapVarchar(_length: number): SQLiteDatabaseType {\n    // SQLite doesn't support varchar - convert to text\n    return \"text\";\n  }\n\n  protected mapBinary(): SQLiteDatabaseType {\n    return \"blob\";\n  }\n\n  protected mapBool(): SQLiteDatabaseType {\n    return \"integer\";\n  }\n\n  protected mapDecimal(): SQLiteDatabaseType {\n    return \"real\";\n  }\n\n  protected mapTimestamp(): SQLiteDatabaseType {\n    return \"integer\";\n  }\n\n  protected mapDate(): SQLiteDatabaseType {\n    return \"integer\";\n  }\n\n  protected mapJson(): SQLiteDatabaseType {\n    return \"text\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAYA,IAAa,mBAAb,cAAsC,cAAkC;CACtE,AAAU,oBAAwC;AAEhD,SAAO;;CAGT,AAAU,WAAW,SAAkE;AACrF,SAAO;;CAGT,AAAU,UAAU,QAAiE;AAEnF,MAAI,UAAU,UAAU,OAAO,SAAS,YACtC,QAAO;AAET,SAAO;;CAGT,AAAU,YAAgC;AACxC,SAAO;;CAGT,AAAU,WAAW,SAAqC;AAExD,SAAO;;CAGT,AAAU,YAAgC;AACxC,SAAO;;CAGT,AAAU,UAA8B;AACtC,SAAO;;CAGT,AAAU,aAAiC;AACzC,SAAO;;CAGT,AAAU,eAAmC;AAC3C,SAAO;;CAGT,AAAU,UAA8B;AACtC,SAAO;;CAGT,AAAU,UAA8B;AACtC,SAAO"}
+{"version":3,"file":"sqlite.js","names":[],"sources":["../../../../src/schema/type-conversion/dialect/sqlite.ts"],"sourcesContent":["import type { AnyColumn } from \"../../create\";\nimport { SQLTypeMapper, type SQLiteDatabaseType } from \"../type-mapping\";\nimport type { SQLiteStorageMode } from \"../../../adapters/generic-sql/sqlite-storage\";\nimport { sqliteStorageDefault } from \"../../../adapters/generic-sql/sqlite-storage\";\n\n/**\n * SQLite-specific type mapper.\n *\n * SQLite has a limited type system with only 4 storage classes:\n * - INTEGER for integers, booleans, timestamps, dates (and reference columns)\n * - BLOB for binary data and bigints (except for reference columns)\n * - TEXT for strings, JSON, and varchar\n * - REAL for decimals\n */\nexport class SQLiteTypeMapper extends SQLTypeMapper<SQLiteDatabaseType> {\n  private readonly sqliteStorageMode: SQLiteStorageMode;\n\n  constructor(database: \"sqlite\", sqliteStorageMode?: SQLiteStorageMode) {\n    super(database);\n    this.sqliteStorageMode = sqliteStorageMode ?? sqliteStorageDefault;\n  }\n\n  protected getInternalIdType(): SQLiteDatabaseType {\n    // SQLite uses INTEGER for auto-increment (INTEGER PRIMARY KEY)\n    return \"integer\";\n  }\n\n  protected mapInteger(_column: AnyColumn | Pick<AnyColumn, \"type\">): SQLiteDatabaseType {\n    return \"integer\";\n  }\n\n  protected mapBigint(column: AnyColumn | Pick<AnyColumn, \"type\">): SQLiteDatabaseType {\n    // SQLite special case: reference columns should use integer even if type is bigint\n    if (\"role\" in column && column.role === \"reference\") {\n      return \"integer\";\n    }\n    if (this.sqliteStorageMode.bigintStorage === \"integer\") {\n      return \"integer\";\n    }\n    return \"blob\";\n  }\n\n  protected mapString(): SQLiteDatabaseType {\n    return \"text\";\n  }\n\n  protected mapVarchar(_length: number): SQLiteDatabaseType {\n    // SQLite doesn't support varchar - convert to text\n    return \"text\";\n  }\n\n  protected mapBinary(): SQLiteDatabaseType {\n    return \"blob\";\n  }\n\n  protected mapBool(): SQLiteDatabaseType {\n    return \"integer\";\n  }\n\n  protected mapDecimal(): SQLiteDatabaseType {\n    return \"real\";\n  }\n\n  protected mapTimestamp(): SQLiteDatabaseType {\n    if (this.sqliteStorageMode.timestampStorage === \"iso-text\") {\n      return \"text\";\n    }\n    return \"integer\";\n  }\n\n  protected mapDate(): SQLiteDatabaseType {\n    if (this.sqliteStorageMode.dateStorage === \"iso-text\") {\n      return \"text\";\n    }\n    return \"integer\";\n  }\n\n  protected mapJson(): SQLiteDatabaseType {\n    return \"text\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,IAAa,mBAAb,cAAsC,cAAkC;CACtE,AAAiB;CAEjB,YAAY,UAAoB,mBAAuC;AACrE,QAAM,SAAS;AACf,OAAK,oBAAoB,qBAAqB;;CAGhD,AAAU,oBAAwC;AAEhD,SAAO;;CAGT,AAAU,WAAW,SAAkE;AACrF,SAAO;;CAGT,AAAU,UAAU,QAAiE;AAEnF,MAAI,UAAU,UAAU,OAAO,SAAS,YACtC,QAAO;AAET,MAAI,KAAK,kBAAkB,kBAAkB,UAC3C,QAAO;AAET,SAAO;;CAGT,AAAU,YAAgC;AACxC,SAAO;;CAGT,AAAU,WAAW,SAAqC;AAExD,SAAO;;CAGT,AAAU,YAAgC;AACxC,SAAO;;CAGT,AAAU,UAA8B;AACtC,SAAO;;CAGT,AAAU,aAAiC;AACzC,SAAO;;CAGT,AAAU,eAAmC;AAC3C,MAAI,KAAK,kBAAkB,qBAAqB,WAC9C,QAAO;AAET,SAAO;;CAGT,AAAU,UAA8B;AACtC,MAAI,KAAK,kBAAkB,gBAAgB,WACzC,QAAO;AAET,SAAO;;CAGT,AAAU,UAA8B;AACtC,SAAO"}

package/dist/schema/validator.d.ts

@@ -0,0 +1,10 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/schema/validator.d.ts
+declare class FragnoDbValidationError extends Error {
+  readonly issues: readonly StandardSchemaV1.Issue[];
+  constructor(message: string, issues: readonly StandardSchemaV1.Issue[]);
+}
+//#endregion
+export { FragnoDbValidationError };
+//# sourceMappingURL=validator.d.ts.map

package/dist/schema/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","names":[],"sources":["../../src/schema/validator.ts"],"sourcesContent":[],"mappings":";;;cASa,uBAAA,SAAgC,KAAA;EAAhC,SAAA,MAAA,EAAA,SACe,gBAAA,CAAiB,KADR,EAAA;EACT,WAAA,CAAA,OAAiB,EAAA,MAAA,EAAA,MAAA,EAAA,SAEG,gBAAA,CAAiB,KAFpB,EAAA"}

package/dist/schema/validator.js

@@ -0,0 +1,123 @@
+//#region src/schema/validator.ts
+var FragnoDbValidationError = class extends Error {
+	issues;
+	constructor(message, issues) {
+		super(message);
+		this.name = "FragnoDbValidationError";
+		this.issues = issues;
+	}
+};
+const defaultUnknownKeysMode = "strip";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseVarcharLength = (type) => {
+	if (!type.startsWith("varchar(") || !type.endsWith(")")) return;
+	const rawLength = type.slice(8, -1);
+	const length = Number(rawLength);
+	if (!Number.isFinite(length)) return;
+	return length;
+};
+const getUnknownKeysMode = (options) => {
+	return (options?.libraryOptions)?.unknownKeys ?? defaultUnknownKeysMode;
+};
+const validateColumnValue = (col, value, classes) => {
+	if (col.role === "external-id") {
+		if (value instanceof classes.FragnoId) {
+			const maxLength = parseVarcharLength(col.type);
+			if (maxLength !== void 0 && value.externalId.length > maxLength) return `String must have at most ${maxLength} characters`;
+			return;
+		}
+		if (typeof value === "string") {
+			const maxLength = parseVarcharLength(col.type);
+			if (maxLength !== void 0 && value.length > maxLength) return `String must have at most ${maxLength} characters`;
+			return;
+		}
+		return "Expected string or FragnoId";
+	}
+	if (col.role === "reference") {
+		if (value instanceof classes.FragnoReference || value instanceof classes.FragnoId || typeof value === "string" || typeof value === "bigint") return;
+		return "Expected reference (string, bigint, FragnoId, or FragnoReference)";
+	}
+	if (col.type === "string" || col.type.startsWith("varchar(")) {
+		if (typeof value !== "string") return "Expected string";
+		const maxLength = parseVarcharLength(col.type);
+		if (maxLength !== void 0 && value.length > maxLength) return `String must have at most ${maxLength} characters`;
+		return;
+	}
+	if (col.type === "bigint") return typeof value === "bigint" ? void 0 : "Expected bigint";
+	if (col.type === "integer") {
+		if (typeof value !== "number" || !Number.isInteger(value)) return "Expected integer";
+		return;
+	}
+	if (col.type === "decimal") {
+		if (typeof value !== "number" || !Number.isFinite(value)) return "Expected number";
+		return;
+	}
+	if (col.type === "bool") return typeof value === "boolean" ? void 0 : "Expected boolean";
+	if (col.type === "binary") return value instanceof Uint8Array ? void 0 : "Expected Uint8Array";
+	if (col.type === "date" || col.type === "timestamp") {
+		if (!(value instanceof Date) || Number.isNaN(value.getTime())) return "Expected valid Date";
+		return;
+	}
+	if (col.type === "json") return;
+};
+const validateTableInsertValues = (table, value, options, classes) => {
+	const issues = [];
+	if (!isRecord(value)) return { issues: [{ message: "Expected object" }] };
+	const input = value;
+	const entries = Object.entries(table.columns).filter(([, col]) => !col.isHidden);
+	const allowedKeys = new Set(entries.map(([key]) => key));
+	if (getUnknownKeysMode(options) === "strict") {
+		for (const key of Object.keys(input)) if (!allowedKeys.has(key)) issues.push({
+			message: `Unknown key "${key}"`,
+			path: [key]
+		});
+	}
+	const output = {};
+	for (const [key, col] of entries) {
+		const colValue = Object.prototype.hasOwnProperty.call(input, key) ? input[key] : void 0;
+		const allowsUndefined = col.isNullable || col.default !== void 0;
+		const allowsNull = col.isNullable;
+		if (colValue === void 0) {
+			if (!allowsUndefined) issues.push({
+				message: "Required",
+				path: [key]
+			});
+			continue;
+		}
+		if (colValue === null) {
+			if (!allowsNull) issues.push({
+				message: "Required",
+				path: [key]
+			});
+			else output[key] = null;
+			continue;
+		}
+		const issue = validateColumnValue(col, colValue, classes);
+		if (issue) {
+			issues.push({
+				message: issue,
+				path: [key]
+			});
+			continue;
+		}
+		output[key] = colValue;
+	}
+	if (issues.length > 0) return { issues };
+	return { value: output };
+};
+const createTableStandardSchemaProps = (table, classes) => ({
+	version: 1,
+	vendor: "fragno-db",
+	validate: (value, options) => validateTableInsertValues(table, value, options, classes)
+});
+const createTableValidator = (table, classes) => {
+	return (value, options) => {
+		const result = validateTableInsertValues(table, value, { libraryOptions: options }, classes);
+		if (result.issues) throw new FragnoDbValidationError("Validation failed", result.issues);
+		return result.value;
+	};
+};
+
+//#endregion
+export { FragnoDbValidationError, createTableStandardSchemaProps, createTableValidator };
+//# sourceMappingURL=validator.js.map

package/dist/schema/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","names":["defaultUnknownKeysMode: TableUnknownKeysMode","issues: StandardSchemaV1.Issue[]","output: Record<string, unknown>"],"sources":["../../src/schema/validator.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type {\n  AnyColumn,\n  Table,\n  TableInsertValues,\n  TableUnknownKeysMode,\n  TableValidationOptions,\n} from \"./create\";\n\nexport class FragnoDbValidationError extends Error {\n  readonly issues: readonly StandardSchemaV1.Issue[];\n\n  constructor(message: string, issues: readonly StandardSchemaV1.Issue[]) {\n    super(message);\n    this.name = \"FragnoDbValidationError\";\n    this.issues = issues;\n  }\n}\n\ntype FragnoIdCtor = typeof import(\"./create\").FragnoId;\ntype FragnoReferenceCtor = typeof import(\"./create\").FragnoReference;\n\ntype ValidationClasses = {\n  FragnoId: FragnoIdCtor;\n  FragnoReference: FragnoReferenceCtor;\n};\n\nconst defaultUnknownKeysMode: TableUnknownKeysMode = \"strip\";\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nconst parseVarcharLength = (type: string): number | undefined => {\n  if (!type.startsWith(\"varchar(\") || !type.endsWith(\")\")) {\n    return;\n  }\n\n  const rawLength = type.slice(\"varchar(\".length, -1);\n  const length = Number(rawLength);\n  if (!Number.isFinite(length)) {\n    return;\n  }\n\n  return length;\n};\n\nconst getUnknownKeysMode = (options?: StandardSchemaV1.Options): TableUnknownKeysMode => {\n  const libraryOptions = options?.libraryOptions as TableValidationOptions | undefined;\n  return libraryOptions?.unknownKeys ?? defaultUnknownKeysMode;\n};\n\nconst validateColumnValue = (\n  col: AnyColumn,\n  value: unknown,\n  classes: ValidationClasses,\n): string | undefined => {\n  if (col.role === \"external-id\") {\n    if (value instanceof classes.FragnoId) {\n      const maxLength = parseVarcharLength(col.type);\n      if (maxLength !== undefined && value.externalId.length > maxLength) {\n        return `String must have at most ${maxLength} characters`;\n      }\n      return;\n    }\n\n    if (typeof value === \"string\") {\n      const maxLength = parseVarcharLength(col.type);\n      if (maxLength !== undefined && value.length > maxLength) {\n        return `String must have at most ${maxLength} characters`;\n      }\n      return;\n    }\n\n    return \"Expected string or FragnoId\";\n  }\n\n  if (col.role === \"reference\") {\n    if (\n      value instanceof classes.FragnoReference ||\n      value instanceof classes.FragnoId ||\n      typeof value === \"string\" ||\n      typeof value === \"bigint\"\n    ) {\n      return;\n    }\n\n    return \"Expected reference (string, bigint, FragnoId, or FragnoReference)\";\n  }\n\n  if (col.type === \"string\" || col.type.startsWith(\"varchar(\")) {\n    if (typeof value !== \"string\") {\n      return \"Expected string\";\n    }\n\n    const maxLength = parseVarcharLength(col.type);\n    if (maxLength !== undefined && value.length > maxLength) {\n      return `String must have at most ${maxLength} characters`;\n    }\n\n    return;\n  }\n\n  if (col.type === \"bigint\") {\n    return typeof value === \"bigint\" ? undefined : \"Expected bigint\";\n  }\n\n  if (col.type === \"integer\") {\n    if (typeof value !== \"number\" || !Number.isInteger(value)) {\n      return \"Expected integer\";\n    }\n    return;\n  }\n\n  if (col.type === \"decimal\") {\n    if (typeof value !== \"number\" || !Number.isFinite(value)) {\n      return \"Expected number\";\n    }\n    return;\n  }\n\n  if (col.type === \"bool\") {\n    return typeof value === \"boolean\" ? undefined : \"Expected boolean\";\n  }\n\n  if (col.type === \"binary\") {\n    return value instanceof Uint8Array ? undefined : \"Expected Uint8Array\";\n  }\n\n  if (col.type === \"date\" || col.type === \"timestamp\") {\n    if (!(value instanceof Date) || Number.isNaN(value.getTime())) {\n      return \"Expected valid Date\";\n    }\n    return;\n  }\n\n  if (col.type === \"json\") {\n    return;\n  }\n\n  return;\n};\n\nconst validateTableInsertValues = <TTable extends Table>(\n  table: TTable,\n  value: unknown,\n  options: StandardSchemaV1.Options | undefined,\n  classes: ValidationClasses,\n): StandardSchemaV1.Result<TableInsertValues<TTable>> => {\n  const issues: StandardSchemaV1.Issue[] = [];\n\n  if (!isRecord(value)) {\n    return { issues: [{ message: \"Expected object\" }] };\n  }\n\n  const input = value as Record<string, unknown>;\n  const entries = Object.entries(table.columns).filter(([, col]) => !col.isHidden);\n  const allowedKeys = new Set(entries.map(([key]) => key));\n  const unknownKeysMode = getUnknownKeysMode(options);\n\n  if (unknownKeysMode === \"strict\") {\n    for (const key of Object.keys(input)) {\n      if (!allowedKeys.has(key)) {\n        issues.push({ message: `Unknown key \"${key}\"`, path: [key] });\n      }\n    }\n  }\n\n  const output: Record<string, unknown> = {};\n\n  for (const [key, col] of entries) {\n    const hasKey = Object.prototype.hasOwnProperty.call(input, key);\n    const colValue = hasKey ? input[key] : undefined;\n    const allowsUndefined = col.isNullable || col.default !== undefined;\n    const allowsNull = col.isNullable;\n\n    if (colValue === undefined) {\n      if (!allowsUndefined) {\n        issues.push({ message: \"Required\", path: [key] });\n      }\n      continue;\n    }\n\n    if (colValue === null) {\n      if (!allowsNull) {\n        issues.push({ message: \"Required\", path: [key] });\n      } else {\n        output[key] = null;\n      }\n      continue;\n    }\n\n    const issue = validateColumnValue(col, colValue, classes);\n    if (issue) {\n      issues.push({ message: issue, path: [key] });\n      continue;\n    }\n\n    output[key] = colValue;\n  }\n\n  if (issues.length > 0) {\n    return { issues };\n  }\n\n  return { value: output as TableInsertValues<TTable> };\n};\n\nexport const createTableStandardSchemaProps = <TTable extends Table>(\n  table: TTable,\n  classes: ValidationClasses,\n): StandardSchemaV1.Props<TableInsertValues<TTable>, TableInsertValues<TTable>> => ({\n  version: 1,\n  vendor: \"fragno-db\",\n  validate: (value: unknown, options?: StandardSchemaV1.Options) =>\n    validateTableInsertValues(table, value, options, classes),\n});\n\nexport const createTableValidator = <TTable extends Table>(\n  table: TTable,\n  classes: ValidationClasses,\n) => {\n  return (value: unknown, options?: TableValidationOptions) => {\n    const result = validateTableInsertValues(table, value, { libraryOptions: options }, classes);\n\n    if (result.issues) {\n      throw new FragnoDbValidationError(\"Validation failed\", result.issues);\n    }\n\n    return result.value as TableInsertValues<TTable>;\n  };\n};\n"],"mappings":";AASA,IAAa,0BAAb,cAA6C,MAAM;CACjD,AAAS;CAET,YAAY,SAAiB,QAA2C;AACtE,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,SAAS;;;AAYlB,MAAMA,yBAA+C;AAErD,MAAM,YAAY,UAChB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,MAAM;AAEtE,MAAM,sBAAsB,SAAqC;AAC/D,KAAI,CAAC,KAAK,WAAW,WAAW,IAAI,CAAC,KAAK,SAAS,IAAI,CACrD;CAGF,MAAM,YAAY,KAAK,MAAM,GAAmB,GAAG;CACnD,MAAM,SAAS,OAAO,UAAU;AAChC,KAAI,CAAC,OAAO,SAAS,OAAO,CAC1B;AAGF,QAAO;;AAGT,MAAM,sBAAsB,YAA6D;AAEvF,SADuB,SAAS,iBACT,eAAe;;AAGxC,MAAM,uBACJ,KACA,OACA,YACuB;AACvB,KAAI,IAAI,SAAS,eAAe;AAC9B,MAAI,iBAAiB,QAAQ,UAAU;GACrC,MAAM,YAAY,mBAAmB,IAAI,KAAK;AAC9C,OAAI,cAAc,UAAa,MAAM,WAAW,SAAS,UACvD,QAAO,4BAA4B,UAAU;AAE/C;;AAGF,MAAI,OAAO,UAAU,UAAU;GAC7B,MAAM,YAAY,mBAAmB,IAAI,KAAK;AAC9C,OAAI,cAAc,UAAa,MAAM,SAAS,UAC5C,QAAO,4BAA4B,UAAU;AAE/C;;AAGF,SAAO;;AAGT,KAAI,IAAI,SAAS,aAAa;AAC5B,MACE,iBAAiB,QAAQ,mBACzB,iBAAiB,QAAQ,YACzB,OAAO,UAAU,YACjB,OAAO,UAAU,SAEjB;AAGF,SAAO;;AAGT,KAAI,IAAI,SAAS,YAAY,IAAI,KAAK,WAAW,WAAW,EAAE;AAC5D,MAAI,OAAO,UAAU,SACnB,QAAO;EAGT,MAAM,YAAY,mBAAmB,IAAI,KAAK;AAC9C,MAAI,cAAc,UAAa,MAAM,SAAS,UAC5C,QAAO,4BAA4B,UAAU;AAG/C;;AAGF,KAAI,IAAI,SAAS,SACf,QAAO,OAAO,UAAU,WAAW,SAAY;AAGjD,KAAI,IAAI,SAAS,WAAW;AAC1B,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,UAAU,MAAM,CACvD,QAAO;AAET;;AAGF,KAAI,IAAI,SAAS,WAAW;AAC1B,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,MAAM,CACtD,QAAO;AAET;;AAGF,KAAI,IAAI,SAAS,OACf,QAAO,OAAO,UAAU,YAAY,SAAY;AAGlD,KAAI,IAAI,SAAS,SACf,QAAO,iBAAiB,aAAa,SAAY;AAGnD,KAAI,IAAI,SAAS,UAAU,IAAI,SAAS,aAAa;AACnD,MAAI,EAAE,iBAAiB,SAAS,OAAO,MAAM,MAAM,SAAS,CAAC,CAC3D,QAAO;AAET;;AAGF,KAAI,IAAI,SAAS,OACf;;AAMJ,MAAM,6BACJ,OACA,OACA,SACA,YACuD;CACvD,MAAMC,SAAmC,EAAE;AAE3C,KAAI,CAAC,SAAS,MAAM,CAClB,QAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,mBAAmB,CAAC,EAAE;CAGrD,MAAM,QAAQ;CACd,MAAM,UAAU,OAAO,QAAQ,MAAM,QAAQ,CAAC,QAAQ,GAAG,SAAS,CAAC,IAAI,SAAS;CAChF,MAAM,cAAc,IAAI,IAAI,QAAQ,KAAK,CAAC,SAAS,IAAI,CAAC;AAGxD,KAFwB,mBAAmB,QAAQ,KAE3B,UACtB;OAAK,MAAM,OAAO,OAAO,KAAK,MAAM,CAClC,KAAI,CAAC,YAAY,IAAI,IAAI,CACvB,QAAO,KAAK;GAAE,SAAS,gBAAgB,IAAI;GAAI,MAAM,CAAC,IAAI;GAAE,CAAC;;CAKnE,MAAMC,SAAkC,EAAE;AAE1C,MAAK,MAAM,CAAC,KAAK,QAAQ,SAAS;EAEhC,MAAM,WADS,OAAO,UAAU,eAAe,KAAK,OAAO,IAAI,GACrC,MAAM,OAAO;EACvC,MAAM,kBAAkB,IAAI,cAAc,IAAI,YAAY;EAC1D,MAAM,aAAa,IAAI;AAEvB,MAAI,aAAa,QAAW;AAC1B,OAAI,CAAC,gBACH,QAAO,KAAK;IAAE,SAAS;IAAY,MAAM,CAAC,IAAI;IAAE,CAAC;AAEnD;;AAGF,MAAI,aAAa,MAAM;AACrB,OAAI,CAAC,WACH,QAAO,KAAK;IAAE,SAAS;IAAY,MAAM,CAAC,IAAI;IAAE,CAAC;OAEjD,QAAO,OAAO;AAEhB;;EAGF,MAAM,QAAQ,oBAAoB,KAAK,UAAU,QAAQ;AACzD,MAAI,OAAO;AACT,UAAO,KAAK;IAAE,SAAS;IAAO,MAAM,CAAC,IAAI;IAAE,CAAC;AAC5C;;AAGF,SAAO,OAAO;;AAGhB,KAAI,OAAO,SAAS,EAClB,QAAO,EAAE,QAAQ;AAGnB,QAAO,EAAE,OAAO,QAAqC;;AAGvD,MAAa,kCACX,OACA,aACkF;CAClF,SAAS;CACT,QAAQ;CACR,WAAW,OAAgB,YACzB,0BAA0B,OAAO,OAAO,SAAS,QAAQ;CAC5D;AAED,MAAa,wBACX,OACA,YACG;AACH,SAAQ,OAAgB,YAAqC;EAC3D,MAAM,SAAS,0BAA0B,OAAO,OAAO,EAAE,gBAAgB,SAAS,EAAE,QAAQ;AAE5F,MAAI,OAAO,OACT,OAAM,IAAI,wBAAwB,qBAAqB,OAAO,OAAO;AAGvE,SAAO,OAAO"}

package/dist/schema-output/drizzle.d.ts

@@ -0,0 +1,30 @@
+import { AnySchema } from "../schema/create.js";
+import { SqlNamingStrategy } from "../naming/sql-naming.js";
+import { SupportedDatabase } from "../adapters/generic-sql/driver-config.js";
+
+//#region src/schema-output/drizzle.d.ts
+type SupportedProvider = SupportedDatabase;
+interface GenerateSchemaOptions {
+  /** Custom ID generator import configuration */
+  idGeneratorImport?: {
+    /** Function name to import */
+    name: string;
+    /** Module to import from */
+    from: string;
+  };
+  /** Optional naming strategy override for physical names */
+  namingStrategy?: SqlNamingStrategy;
+}
+/**
+ * Generate a settings table for storing fragment versions
+ */
+/**
+ * Generate a schema file from one or more fragments with automatic de-duplication
+ */
+declare function generateDrizzleSchema(fragments: {
+  namespace: string | null;
+  schema: AnySchema;
+}[], provider: SupportedDatabase, options?: GenerateSchemaOptions): string;
+//#endregion
+export { GenerateSchemaOptions, SupportedProvider, generateDrizzleSchema };
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/schema-output/drizzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.d.ts","names":[],"sources":["../../src/schema-output/drizzle.ts"],"sourcesContent":[],"mappings":";;;;;KAuCY,iBAAA,GAAoB;UA4nBf,qBAAA;EA5nBL;EA4nBK,iBAAA,CAAA,EAAA;IAkBD;IACiC,IAAA,EAAA,MAAA;IACrC;IACA,IAAA,EAAA,MAAA;EAAqB,CAAA;;mBAZd;;;;;;;;iBASH,qBAAA;;UACiC;eACrC,6BACA"}

package/dist/{adapters/drizzle/generate.js → schema-output/drizzle.js}

@@ -1,10 +1,12 @@
-import { InternalIdColumn } from "../../schema/create.js";
-import { importGenerator } from "../../util/import-generator.js";
-import { ident, parseVarchar } from "../../util/parse.js";
-import { createTableNameMapper, sanitizeNamespace } from "../shared/table-name-mapper.js";
-import { createSQLTypeMapper } from "../../schema/type-conversion/create-sql-type-mapper.js";
+import { InternalIdColumn } from "../schema/create.js";
+import { internalSchema } from "../fragments/internal-fragment.schema.js";
+import { createNamingResolver, sanitizeNamespace } from "../naming/sql-naming.js";
+import { createSQLTypeMapper } from "../schema/type-conversion/create-sql-type-mapper.js";
+import { defaultNamingStrategyForDatabase } from "../adapters/generic-sql/driver-config.js";
+import { importGenerator } from "../util/import-generator.js";
+import { ident, parseVarchar } from "../util/parse.js";
 
-//#region src/adapters/drizzle/generate.ts
+//#region src/schema-output/drizzle.ts
 const PROVIDER_IMPORTS = {
 	mysql: "drizzle-orm/mysql-core",
 	postgresql: "drizzle-orm/pg-core",
@@ -133,7 +135,7 @@ function mapDBTypeToDrizzleFunction(ctx, dbType, column, customTypes) {
 			};
 		case "text":
 			if (column.type === "json") return {
-				name: "blob",
+				name: "text",
 				params: [`{ mode: "json" }`]
 			};
 			return { name: "text" };
@@ -143,16 +145,15 @@ function mapDBTypeToDrizzleFunction(ctx, dbType, column, customTypes) {
 	return { name: dbType };
 }
 /**
-* Get the physical table name (with namespace suffix) using the mapper if available
+* Get the physical table name using the naming resolver if available
 */
-function getPhysicalTableName(logicalName, namespace, mapper) {
-	if (!namespace) return logicalName;
-	return mapper ? mapper.toPhysical(logicalName) : `${logicalName}_${sanitizeNamespace(namespace)}`;
+function getPhysicalTableName(logicalName, resolver) {
+	return resolver ? resolver.getTableName(logicalName) : logicalName;
 }
-function generateColumnDefinition(ctx, column, customTypes) {
+function generateColumnDefinition(ctx, column, customTypes, physicalColumnName) {
 	const parts = [];
 	const typeFn = getColumnTypeFunction(ctx, column, customTypes);
-	const params = [`"${column.name}"`, ...typeFn.params ?? []];
+	const params = [`"${physicalColumnName}"`, ...typeFn.params ?? []];
 	if (!typeFn.isCustomType) ctx.imports.addImport(typeFn.name, ctx.importSource);
 	parts.push(`${typeFn.name}(${params.join(", ")})`);
 	if (column instanceof InternalIdColumn || column.role === "internal-id") if (ctx.provider === "sqlite") parts.push("primaryKey({ autoIncrement: true })");
@@ -161,6 +162,7 @@ function generateColumnDefinition(ctx, column, customTypes) {
 		parts.push("autoincrement()");
 	} else parts.push("primaryKey()");
 	if (!column.isNullable) parts.push("notNull()");
+	if (column.role === "external-id") parts.push("unique()");
 	if (column.default) {
 		if ("value" in column.default) {
 			let value;
@@ -170,7 +172,10 @@ function generateColumnDefinition(ctx, column, customTypes) {
 			} else value = JSON.stringify(column.default.value);
 			parts.push(`default(${value})`);
 		} else if ("dbSpecial" in column.default) {
-			if (column.default.dbSpecial === "now") parts.push("defaultNow()");
+			if (column.default.dbSpecial === "now") if (ctx.provider === "mysql") {
+				ctx.imports.addImport("sql", "drizzle-orm");
+				parts.push("default(sql`(now())`)");
+			} else parts.push("defaultNow()");
 		} else if ("runtime" in column.default) {
 			if (column.default.runtime === "cuid") {
 				const idGen = ctx.idGeneratorImport ?? {
@@ -182,29 +187,33 @@ function generateColumnDefinition(ctx, column, customTypes) {
 			} else if (column.default.runtime === "now") parts.push("$defaultFn(() => new Date())");
 		}
 	}
-	return `  ${column.ormName}: ${parts.join(".")}`;
+	return `  ${column.name}: ${parts.join(".")}`;
 }
-function generateAllColumns(ctx, table, customTypes) {
-	return Object.values(table.columns).map((column) => generateColumnDefinition(ctx, column, customTypes));
+function generateAllColumns(ctx, table, customTypes, resolver) {
+	return Object.values(table.columns).map((column) => generateColumnDefinition(ctx, column, customTypes, resolver ? resolver.getColumnName(table.name, column.name) : column.name));
 }
-function generateForeignKeys(ctx, table, namespace, mapper) {
+function generateForeignKeys(ctx, table, namespace, resolver) {
 	const keys = [];
 	for (const relation of Object.values(table.relations)) {
 		if (relation.type === "many") continue;
 		const columns = [];
 		const foreignColumns = [];
-		const isSelfReference = relation.table.ormName === table.ormName;
+		const isSelfReference = relation.table.name === table.name;
 		for (const [localCol, refCol] of relation.on) {
 			columns.push(`table.${localCol}`);
 			const actualRefCol = refCol === "id" ? "_internalId" : refCol;
 			if (isSelfReference) foreignColumns.push(`table.${actualRefCol}`);
 			else {
-				const foreignTableRef = namespace ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}` : relation.table.ormName;
+				const foreignTableRef = namespace ? `${relation.table.name}_${sanitizeNamespace(namespace)}` : relation.table.name;
 				foreignColumns.push(`${foreignTableRef}.${actualRefCol}`);
 			}
 		}
 		ctx.imports.addImport("foreignKey", ctx.importSource);
-		const fkName = namespace && mapper ? "fk_" + mapper.toPhysical(`${table.ormName}_${relation.table.ormName}_${relation.name}`) : `${table.ormName}_${relation.table.ormName}_${relation.name}_fk`;
+		const fkName = resolver ? resolver.getForeignKeyName({
+			logicalTable: table.name,
+			logicalReferencedTable: relation.table.name,
+			referenceName: relation.name
+		}) : `${table.name}_${relation.table.name}_${relation.name}_fk`;
 		keys.push(`foreignKey({
   columns: [${columns.join(", ")}],
   foreignColumns: [${foreignColumns.join(", ")}],
@@ -213,11 +222,11 @@ function generateForeignKeys(ctx, table, namespace, mapper) {
 	}
 	return keys;
 }
-function generateIndexes(ctx, table, namespace) {
+function generateIndexes(ctx, table, namespace, resolver) {
 	const indexes = [];
 	for (const idx of Object.values(table.indexes)) {
-		const columns = idx.columns.map((col) => `table.${col.ormName}`).join(", ");
-		const indexName = namespace ? `${idx.name}_${namespace}` : idx.name;
+		const columns = idx.columns.map((col) => `table.${col.name}`).join(", ");
+		const indexName = resolver ? idx.unique ? resolver.getUniqueIndexName(idx.name, table.name) : resolver.getIndexName(idx.name, table.name) : namespace ? `${idx.name}_${namespace}` : idx.name;
 		if (idx.unique) {
 			ctx.imports.addImport("uniqueIndex", ctx.importSource);
 			indexes.push(`uniqueIndex("${indexName}").on(${columns})`);
@@ -228,21 +237,30 @@ function generateIndexes(ctx, table, namespace) {
 	}
 	return indexes;
 }
-function generateTableConstraints(ctx, table, namespace, mapper) {
-	return [...generateForeignKeys(ctx, table, namespace, mapper), ...generateIndexes(ctx, table, namespace)];
+function generateTableConstraints(ctx, table, namespace, resolver) {
+	const constraints = [...generateForeignKeys(ctx, table, namespace, resolver), ...generateIndexes(ctx, table, namespace, resolver)];
+	if (ctx.provider === "sqlite") {
+		const externalIdColumn = Object.values(table.columns).find((column) => column.role === "external-id");
+		if (externalIdColumn) {
+			const indexName = resolver ? resolver.getUniqueIndexName(`idx_${table.name}_external_id`, table.name) : namespace ? `idx_${table.name}_external_id_${namespace}` : `idx_${table.name}_external_id`;
+			ctx.imports.addImport("uniqueIndex", ctx.importSource);
+			constraints.push(`uniqueIndex("${indexName}").on(table.${externalIdColumn.name})`);
+		}
+	}
+	return constraints;
 }
-function generateTable(ctx, table, customTypes, namespace, mapper) {
-	const tableFn = PROVIDER_TABLE_FUNCTIONS[ctx.provider];
-	ctx.imports.addImport(tableFn, ctx.importSource);
-	const columns = generateAllColumns(ctx, table, customTypes);
-	const constraints = generateTableConstraints(ctx, table, namespace, mapper);
-	const physicalTableName = getPhysicalTableName(table.ormName, namespace, mapper);
-	const exportName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
+function generateTable(ctx, table, customTypes, namespace, resolver, schemaRef) {
+	const tableFn = schemaRef ? `${schemaRef}.table` : PROVIDER_TABLE_FUNCTIONS[ctx.provider];
+	if (!schemaRef) ctx.imports.addImport(tableFn, ctx.importSource);
+	const columns = generateAllColumns(ctx, table, customTypes, resolver);
+	const constraints = generateTableConstraints(ctx, table, namespace, resolver);
+	const physicalTableName = getPhysicalTableName(table.name, resolver);
+	const exportName = namespace ? `${table.name}_${sanitizeNamespace(namespace)}` : table.name;
 	const args = [`"${physicalTableName}"`, `{\n${columns.join(",\n")}\n}`];
 	if (constraints.length > 0) args.push(`(table) => [\n${ident(constraints.join(",\n"))}\n]`);
 	return `export const ${exportName} = ${tableFn}(${args.join(", ")})`;
 }
-function generateRelation(ctx, table, namespace, inverseRelations, _mapper) {
+function generateRelation(ctx, table, namespace, inverseRelations, _resolver) {
 	const relations = [];
 	let hasOne = false;
 	let hasMany = false;
@@ -253,8 +271,8 @@ function generateRelation(ctx, table, namespace, inverseRelations, _mapper) {
 		if (relation.type === "one") {
 			const fields = [];
 			const references = [];
-			const tableRef = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
-			const relatedTableRef = namespace ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}` : relation.table.ormName;
+			const tableRef = namespace ? `${table.name}_${sanitizeNamespace(namespace)}` : table.name;
+			const relatedTableRef = namespace ? `${relation.table.name}_${sanitizeNamespace(namespace)}` : relation.table.name;
 			for (const [left, right] of relation.on) {
 				fields.push(`${tableRef}.${left}`);
 				const actualRight = right === "id" ? "_internalId" : right;
@@ -262,15 +280,15 @@ function generateRelation(ctx, table, namespace, inverseRelations, _mapper) {
 			}
 			options.push(`fields: [${fields.join(", ")}]`, `references: [${references.join(", ")}]`);
 		}
-		const args = [namespace ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}` : relation.table.ormName];
+		const args = [namespace ? `${relation.table.name}_${sanitizeNamespace(namespace)}` : relation.table.name];
 		if (options.length > 0) args.push(`{\n${ident(options.join(",\n"))}\n}`);
 		relations.push(ident(`${relation.name}: ${relation.type}(${args.join(", ")})`));
 	}
 	if (inverseRelations && inverseRelations.length > 0) {
 		for (const { fromTable, relation } of inverseRelations) if (relation.type === "one") {
 			hasMany = true;
-			const fromTableRef = namespace ? `${fromTable.ormName}_${sanitizeNamespace(namespace)}` : fromTable.ormName;
-			const inverseRelationName = `${fromTable.ormName}List`;
+			const fromTableRef = namespace ? `${fromTable.name}_${sanitizeNamespace(namespace)}` : fromTable.name;
+			const inverseRelationName = `${fromTable.name}List`;
 			const args = [fromTableRef, `{\n${ident([`relationName: "${relation.id}"`].join(",\n"))}\n}`];
 			relations.push(ident(`${inverseRelationName}: many(${args.join(", ")})`));
 		}
@@ -280,8 +298,8 @@ function generateRelation(ctx, table, namespace, inverseRelations, _mapper) {
 	if (hasOne) params.push("one");
 	if (hasMany) params.push("many");
 	const relationParams = params.length > 0 ? `{ ${params.join(", ")} }` : "{}";
-	const exportTableRef = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
-	const relationsName = namespace ? `${exportTableRef}Relations` : `${table.ormName}Relations`;
+	const exportTableRef = namespace ? `${table.name}_${sanitizeNamespace(namespace)}` : table.name;
+	const relationsName = namespace ? `${exportTableRef}Relations` : `${table.name}Relations`;
 	ctx.imports.addImport("relations", "drizzle-orm");
 	return `export const ${relationsName} = relations(${exportTableRef}, (${relationParams}) => ({
 ${relations.join(",\n")}
@@ -291,20 +309,20 @@ ${relations.join(",\n")}
 * Generate a schema export object for a fragment
 * This groups all tables by their logical names for easier access
 */
-function generateFragmentSchemaExport(schema, namespace, tablesWithRelations, _mapper) {
+function generateFragmentSchemaExport(schema, namespace, tablesWithRelations, _resolver) {
 	const drizzleEntries = [];
 	for (const table of Object.values(schema.tables)) {
-		const exportName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
+		const exportName = namespace ? `${table.name}_${sanitizeNamespace(namespace)}` : table.name;
 		drizzleEntries.push(`  ${exportName}: ${exportName}`);
 		if (tablesWithRelations?.has(table.name)) {
-			const relationsName = namespace ? `${exportName}Relations` : `${table.ormName}Relations`;
+			const relationsName = namespace ? `${exportName}Relations` : `${table.name}Relations`;
 			drizzleEntries.push(`  ${relationsName}: ${relationsName}`);
 		}
 		if (namespace) {
-			drizzleEntries.push(`  ${table.ormName}: ${exportName}`);
+			drizzleEntries.push(`  ${table.name}: ${exportName}`);
 			if (tablesWithRelations?.has(table.name)) {
 				const physicalRelationsName = `${exportName}Relations`;
-				const aliasRelationsName = `${table.ormName}Relations`;
+				const aliasRelationsName = `${table.name}Relations`;
 				drizzleEntries.push(`  ${aliasRelationsName}: ${physicalRelationsName}`);
 			}
 		}
@@ -318,20 +336,28 @@ function generateFragmentSchemaExport(schema, namespace, tablesWithRelations, _m
 /**
 * Generate a schema file from one or more fragments with automatic de-duplication
 */
-function generateSchema(fragments, provider, options) {
+function generateDrizzleSchema(fragments, provider, options) {
 	const ctx = createContext(provider, options?.idGeneratorImport);
 	const customTypes = [];
 	const sections = [];
-	const getMapper = options?.mapperFactory || ((ns) => ns ? createTableNameMapper(ns, true) : void 0);
+	const namingStrategy = options?.namingStrategy ?? defaultNamingStrategyForDatabase(provider);
 	for (const { schema, namespace } of fragments) {
 		const fragmentTables = [];
-		const mapper = getMapper(namespace);
+		const resolver = createNamingResolver(schema, namespace, namingStrategy);
+		const schemaName = resolver.getSchemaName();
+		const schemaRef = ctx.provider === "postgresql" && schemaName ? `schema_${sanitizeNamespace(schemaName)}` : void 0;
 		fragmentTables.push("");
 		fragmentTables.push("// ============================================================================");
-		fragmentTables.push(`// Fragment: ${namespace}`);
+		const namespaceLabel = namespace ?? "(none)";
+		fragmentTables.push(`// Fragment: ${namespaceLabel}`);
 		fragmentTables.push("// ============================================================================");
+		if (schemaRef && schemaName) {
+			ctx.imports.addImport("pgSchema", ctx.importSource);
+			fragmentTables.push("");
+			fragmentTables.push(`const ${schemaRef} = pgSchema("${schemaName}");`);
+		}
 		for (const table of Object.values(schema.tables)) {
-			const tableCode = generateTable(ctx, table, customTypes, namespace, mapper);
+			const tableCode = generateTable(ctx, table, customTypes, namespace, resolver, schemaRef);
 			fragmentTables.push("");
 			fragmentTables.push(tableCode);
 		}
@@ -346,16 +372,16 @@ function generateSchema(fragments, provider, options) {
 		}
 		const tablesWithRelations = /* @__PURE__ */ new Set();
 		for (const table of Object.values(schema.tables)) {
-			const relationCode = generateRelation(ctx, table, namespace, inverseRelations.get(table.name), mapper);
+			const relationCode = generateRelation(ctx, table, namespace, inverseRelations.get(table.name), resolver);
 			if (relationCode) {
 				fragmentTables.push("");
 				fragmentTables.push(relationCode);
 				tablesWithRelations.add(table.name);
 			}
 		}
-		if (namespace !== "") {
+		if (!(namespace === null && schema.name === internalSchema.name)) {
 			fragmentTables.push("");
-			fragmentTables.push(generateFragmentSchemaExport(schema, namespace, tablesWithRelations, mapper));
+			fragmentTables.push(generateFragmentSchemaExport(schema, namespace, tablesWithRelations));
 		}
 		sections.push(...fragmentTables);
 	}
@@ -367,5 +393,5 @@ function generateSchema(fragments, provider, options) {
 }
 
 //#endregion
-export { generateSchema };
-//# sourceMappingURL=generate.js.map
+export { generateDrizzleSchema };
+//# sourceMappingURL=drizzle.js.map