durcno 1.0.0-alpha.11 → 1.0.0-alpha.12

package/dist/bin.cjs

@@ -10247,6 +10247,7 @@ function formatValue(value) {
 // src/cli/commands/squash.ts
 var import_node_fs4 = require("node:fs");
 var import_node_path7 = require("node:path");
+var import_durcno4 = require("durcno");
 var import_migration3 = require("durcno/migration");
 var { bgGreen: bgGreen4, bgRed: bgRed2, yellow: yellow7, red: red5, green: green4, cyan: cyan7, gray: gray6 } = source_default;
 async function squash(start, end, options) {
@@ -10286,6 +10287,35 @@ async function squash(start, end, options) {
     console.log(yellow7("Only one migration in range. Nothing to squash."));
     process.exit(0);
   }
+  let client = null;
+  let rangeAllApplied = false;
+  if (!options.skipDb) {
+    client = config.connector.getClient();
+    await client.connect();
+    if (await migrationsTableExists(client)) {
+      config.connector.options.pool = {
+        ...config.connector.options.pool,
+        max: 1
+      };
+      config.connector.options.logger = void 0;
+      const db = (0, import_durcno4.database)({ Migrations: import_durcno4.Migrations }, config);
+      const records = await db.from(import_durcno4.Migrations).select();
+      await db.close();
+      const appliedNames = new Set(records.map((r) => r.name));
+      const appliedInRange = range.filter((m) => appliedNames.has(m));
+      const unappliedInRange = range.filter((m) => !appliedNames.has(m));
+      if (appliedInRange.length > 0 && unappliedInRange.length > 0) {
+        await client.close();
+        console.error(
+          bgRed2.white("[ERROR]") + " " + red5("Cannot squash a mix of applied and unapplied migrations.") + gray6(`
+  Applied in range:   ${appliedInRange.join(", ")}`) + gray6(`
+  Unapplied in range: ${unappliedInRange.join(", ")}`)
+        );
+        process.exit(1);
+      }
+      rangeAllApplied = unappliedInRange.length === 0;
+    }
+  }
   let hasCustomStatements = false;
   for (const migrationDirName of range) {
     const upPath = (0, import_node_path7.join)(migrationsDir, migrationDirName, "up.ts");
@@ -10346,6 +10376,22 @@ async function squash(start, end, options) {
   (0, import_node_fs4.mkdirSync)(squashedDir, { recursive: true });
   (0, import_node_fs4.writeFileSync)((0, import_node_path7.join)(squashedDir, "up.ts"), squashedUpTs);
   (0, import_node_fs4.writeFileSync)((0, import_node_path7.join)(squashedDir, "down.ts"), squashedDownTs);
+  if (client !== null && rangeAllApplied) {
+    config.connector.options.pool = {
+      ...config.connector.options.pool,
+      max: 1
+    };
+    config.connector.options.logger = void 0;
+    const db = (0, import_durcno4.database)({ Migrations: import_durcno4.Migrations }, config);
+    for (const migrationName of range) {
+      await db.delete(import_durcno4.Migrations).where((0, import_durcno4.eq)(import_durcno4.Migrations.name, migrationName));
+    }
+    await db.insert(import_durcno4.Migrations).values({ name: start, createdAt: /* @__PURE__ */ new Date() });
+    await db.close();
+  }
+  if (client !== null) {
+    await client.close();
+  }
   console.log(
     bgGreen4.white.bold("[SQUASHED]") + " " + green4(`${cyan7(String(range.length))} migrations into ${cyan7(start)}.`)
   );
@@ -10354,7 +10400,7 @@ async function squash(start, end, options) {
 
 // src/cli/commands/status.ts
 var import_node_path8 = require("node:path");
-var import_durcno4 = require("durcno");
+var import_durcno5 = require("durcno");
 var { dim: dim4, cyan: cyan8, yellow: yellow8, green: green5 } = source_default;
 async function status(options) {
   const configPath = resolveConfigPath(options.config);
@@ -10372,8 +10418,8 @@ async function status(options) {
   }
   connector.options.pool = { ...connector.options.pool, max: 1 };
   connector.options.logger = void 0;
-  const db = (0, import_durcno4.database)({ Migrations: import_durcno4.Migrations }, config);
-  const migrationsQuery = db.from(import_durcno4.Migrations).select();
+  const db = (0, import_durcno5.database)({ Migrations: import_durcno5.Migrations }, config);
+  const migrationsQuery = db.from(import_durcno5.Migrations).select();
   let migrations;
   const client = connector.getClient();
   await client.connect();
@@ -10405,7 +10451,7 @@ async function status(options) {
 }
 
 // src/cli/index.ts
-program.version("1.0.0-alpha.10");
+program.version("1.0.0-alpha.11");
 var Options = {
   config: ["--config <path>", "Path to the config file"]
 };
@@ -10430,7 +10476,10 @@ program.command("status").alias("stat").option(...Options.config).description("s
 program.command("down <migration>").option(...Options.config).description("down a specific migration").action(async (migration, opts) => {
   await down(migration, opts);
 });
-program.command("squash <start> <end>").option(...Options.config).option("--force", "Squash even if custom statements exist").description("squash a range of migrations into a single migration").action(
+program.command("squash <start> <end>").option(...Options.config).option("--force", "Squash even if custom statements exist").option(
+  "--skip-db",
+  "Skip all database interaction (no validation, no tracking update)"
+).description("squash a range of migrations into a single migration").action(
   async (start, end, opts) => {
     await squash(start, end, opts);
   }

package/dist/src/columns/common.d.mts

@@ -1,6 +1,5 @@
 import { entityType } from "../symbols.mjs";
-import { Key } from "../types.mjs";
-import { StdTable, StdTableColumn, TableColumn } from "../table.mjs";
+import { StdTable, StdTableColumn } from "../table.mjs";
 import { Arg } from "../query-builders/pre.mjs";
 import { Query, QueryContext } from "../query-builders/query.mjs";
 import { Sql } from "../sql.mjs";
@@ -10,19 +9,59 @@ import * as z from "zod";
 declare const notNull: true;
 declare const unique: true;
 declare const primaryKey: true;
+/**
+ * Represents the dimension configuration for an array column.
+ */
+declare class Dimension<TDims extends readonly (number | null)[]> {
+  /** The raw dimension tuple (first = innermost dimension). */
+  readonly dims: TDims;
+  constructor(dims: TDims);
+  /**
+   * Appends a variable-length (unbounded) outer dimension.
+   * SQL equivalent: `type[]`
+   */
+  array(): Dimension<readonly [...TDims, null]>;
+  /**
+   * Appends a fixed-length outer dimension of `size` elements.
+   * SQL equivalent: `type[N]`
+   */
+  tuple<const L extends number>(size: L): Dimension<readonly [...TDims, L]>;
+}
+/**
+ * Creates a variable-length (unbounded) 1D array dimension.
+ * SQL equivalent: `type[]`
+ *
+ * @example
+ * ```typescript
+ * tags: varchar({ length: 50, dimension: array() })
+ * ```
+ */
+declare function array(): Dimension<readonly [null]>;
+/**
+ * Creates a fixed-length 1D array dimension of `size` elements.
+ * SQL equivalent: `type[N]`
+ *
+ * @example
+ * ```typescript
+ * coordinates: integer({ dimension: tuple(3) })
+ * ```
+ */
+declare function tuple<const L extends number>(size: L): Dimension<readonly [L]>;
 type Tuple<T, L extends number, Acc extends T[] = []> = Acc["length"] extends L ? Acc : Tuple<T, L, [...Acc, T]>;
 type MultiDimValueArray<T, D extends readonly (number | null)[]> = D extends readonly [infer First, ...infer Rest] ? First extends number ? Rest extends readonly (number | null)[] ? MultiDimValueArray<Tuple<T, First>, Rest> : never : First extends null ? Rest extends readonly (number | null)[] ? MultiDimValueArray<T[], Rest> : never : never : T;
 type GetValueArray<T, TConfig> = TConfig extends {
-  dimension: infer D;
-} ? D extends readonly (number | null)[] ? MultiDimValueArray<T, D> : T : T;
+  dimension: Dimension<infer Dims>;
+} ? Dims extends readonly (number | null)[] ? MultiDimValueArray<T, Dims> : T : T;
 type MultiDimZodTypeArray<T extends z.ZodType, D extends readonly (number | null)[]> = D extends readonly [infer First, ...infer Rest] ? First extends number ? Rest extends readonly (number | null)[] ? MultiDimZodTypeArray<z.ZodTuple<Tuple<T, First>, null>, Rest> : never : First extends null ? Rest extends readonly (number | null)[] ? MultiDimZodTypeArray<z.ZodArray<T>, Rest> : never : never : T;
 type GetZodTypeArray<T extends z.ZodType, TConfig> = TConfig extends {
-  dimension: infer D;
-} ? D extends readonly (number | null)[] ? MultiDimZodTypeArray<T, D> : T : T;
+  dimension: Dimension<infer Dims>;
+} ? Dims extends readonly (number | null)[] ? MultiDimZodTypeArray<T, Dims> : T : T;
 interface TableLike {
   _: {
     schema: string;
     name: string;
+    schemaSql: string;
+    nameSql: string;
   };
 }
 declare const OnDeleteActions: readonly ["CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION"];
@@ -42,8 +81,9 @@ type ColumnConfig = {
   notNull?: true;
   /**
    * The dimension of the array column.
+   * Use the `array()` or `tuple(size)` helpers to define dimensions.
    */
-  dimension?: Readonly<[number | null, ...(number | null)[]]>;
+  dimension?: Dimension<readonly (number | null)[]>;
 };
 /**
  * Type that augments C with a `hasDefault` property set to true.
@@ -77,8 +117,8 @@ type HasUpdateFn<C> = C & {
  * Supports either a direct column resolver function or an object with
  * a resolver and optional `onDelete` action.
  */
-type BuildRef<ValType> = (() => TableColumn<string, string, Key, Column<any, ValType, any>>) | {
-  column: () => TableColumn<string, string, Key, Column<any, ValType, any>>;
+type BuildRef<ValType> = (() => StdTableColumn<Column<any, ValType>>) | {
+  column: () => StdTableColumn<Column<any, ValType>>;
   onDelete?: OnDeleteAction;
 };
 /**
@@ -104,7 +144,9 @@ declare abstract class Column<TConfig extends ColumnConfig, TColVal, TPgType ext
   readonly $: {
     /** Phantom discriminant id for this entity kind. */kind: "column"; /** The PostgreSQL type category for this column. */
     PgType: TPgType; /** The TypeScript type for this column's value. */
-    TsType: TColVal;
+    TsType: TColVal; /** Phantom schema and table references for this column. */
+    schema: string | undefined;
+    table: string | undefined;
     HasValTypeOverridde: {};
     ValTypeOverride: {};
   };
@@ -151,6 +193,10 @@ declare abstract class Column<TConfig extends ColumnConfig, TColVal, TPgType ext
   get isNotNull(): TConfig extends {
     notNull: true;
   } ? true : false;
+  /**
+   * Returns the raw dimension tuple from the column config, or `undefined` if not set.
+   */
+  get dimensions(): Readonly<[number | null, ...(number | null)[]]> | undefined;
   abstract get sqlTypeScalar(): string;
   get sqlType(): string;
   /** Returns the PostgreSQL cast type for this column's scalar value, or `null` if no cast is needed. */
@@ -255,4 +301,4 @@ declare abstract class Column<TConfig extends ColumnConfig, TColVal, TPgType ext
   arg(): Arg<this["ValType"]>;
 }
 //#endregion
-export { Column, ColumnConfig, GeneratedAlways, GeneratedByDefault, OnDeleteAction, notNull, primaryKey, unique };
+export { Column, ColumnConfig, Dimension, GeneratedAlways, GeneratedByDefault, OnDeleteAction, array, notNull, primaryKey, tuple, unique };

package/dist/src/columns/common.mjs

@@ -9,6 +9,54 @@ const notNull = true;
 const unique = true;
 const primaryKey = true;
 const identity = "IDENTITY";
+/**
+* Represents the dimension configuration for an array column.
+*/
+var Dimension = class Dimension {
+	/** The raw dimension tuple (first = innermost dimension). */
+	dims;
+	constructor(dims) {
+		this.dims = dims;
+	}
+	/**
+	* Appends a variable-length (unbounded) outer dimension.
+	* SQL equivalent: `type[]`
+	*/
+	array() {
+		return new Dimension([...this.dims, null]);
+	}
+	/**
+	* Appends a fixed-length outer dimension of `size` elements.
+	* SQL equivalent: `type[N]`
+	*/
+	tuple(size) {
+		return new Dimension([...this.dims, size]);
+	}
+};
+/**
+* Creates a variable-length (unbounded) 1D array dimension.
+* SQL equivalent: `type[]`
+*
+* @example
+* ```typescript
+* tags: varchar({ length: 50, dimension: array() })
+* ```
+*/
+function array() {
+	return new Dimension([null]);
+}
+/**
+* Creates a fixed-length 1D array dimension of `size` elements.
+* SQL equivalent: `type[N]`
+*
+* @example
+* ```typescript
+* coordinates: integer({ dimension: tuple(3) })
+* ```
+*/
+function tuple(size) {
+	return new Dimension([size]);
+}
 var Column = class {
 	static [entityType] = "Column";
 	config;
@@ -62,22 +110,28 @@ var Column = class {
 	get isNotNull() {
 		return this.#notNull;
 	}
+	/**
+	* Returns the raw dimension tuple from the column config, or `undefined` if not set.
+	*/
+	get dimensions() {
+		return this.config.dimension?.dims;
+	}
 	get sqlType() {
 		const base = this.sqlTypeScalar;
-		if (!this.config.dimension) return base;
-		return `${base}${this.config.dimension.map((d) => d === null ? "[]" : `[${d}]`).join("")}`;
+		if (!this.dimensions) return base;
+		return `${base}${this.dimensions.map((d) => d === null ? "[]" : `[${d}]`).join("")}`;
 	}
 	/** Returns the full PostgreSQL cast type including array dimensions, or `null` if no cast is needed. */
 	get sqlCast() {
 		const base = this.sqlCastScalar;
 		if (base === null) return null;
-		if (!this.config.dimension) return base;
-		return `${base}${this.config.dimension.map((d) => d === null ? "[]" : `[${d}]`).join("")}`;
+		if (!this.dimensions) return base;
+		return `${base}${this.dimensions.map((d) => d === null ? "[]" : `[${d}]`).join("")}`;
 	}
 	get zodType() {
 		let schema = this.zodTypeScaler;
-		if (!this.config.dimension) return schema;
-		for (const dim of this.config.dimension) if (typeof dim === "number") schema = z.tuple(Array.from({ length: dim }, () => schema));
+		if (!this.dimensions) return schema;
+		for (const dim of this.dimensions) if (typeof dim === "number") schema = z.tuple(Array.from({ length: dim }, () => schema));
 		else schema = z.array(schema);
 		return schema;
 	}
@@ -86,7 +140,7 @@ var Column = class {
 	* @returns string `"table"."column"`
 	*/
 	get fullName() {
-		return `"${this.table?._.name}"."${this.nameSql}"`;
+		return `"${this.table?._.nameSql}"."${this.nameSql}"`;
 	}
 	toQuery(query, ctx) {
 		const alias = ctx?.tableAliases?.get(`${this.table?._.schema}.${this.table?._.name}`);
@@ -101,14 +155,14 @@ var Column = class {
 	toDriver(value) {
 		if (value === null) return null;
 		if (value instanceof Sql) return value.string;
-		if (!this.config.dimension) return this.toDriverScalar(value);
+		if (!this.dimensions) return this.toDriverScalar(value);
 		return value.map((item) => this.#toDriverArrayElement(item, 0));
 	}
 	/**
 	* Helper to recursively process multi-dimensional arrays for toDriver.
 	*/
 	#toDriverArrayElement(value, dimIndex) {
-		if (dimIndex >= this.config.dimension.length - 1) return this.toDriverScalar(value);
+		if (dimIndex >= this.dimensions.length - 1) return this.toDriverScalar(value);
 		return value.map((item) => this.#toDriverArrayElement(item, dimIndex + 1));
 	}
 	/**
@@ -118,7 +172,7 @@ var Column = class {
 	toSQL(value, options) {
 		if (value === null) return "NULL";
 		if (value instanceof Sql) return value.string;
-		if (!this.config.dimension) {
+		if (!this.dimensions) {
 			if (!options?.cast || !this.sqlCastScalar) return this.toSQLScalar(value);
 			return `${this.toSQLScalar(value)}::${this.sqlCastScalar}`;
 		}
@@ -128,7 +182,7 @@ var Column = class {
 	* Helper to recursively process multi-dimensional arrays for toSQL.
 	*/
 	#toSQLArray(arr, dimIndex, options) {
-		const dimensions = this.config.dimension;
+		const dimensions = this.dimensions;
 		if (arr.length === 0) return "'{}'";
 		if (dimIndex >= dimensions.length - 1) return `ARRAY[${arr.map((item) => {
 			if (!options?.cast || !this.sqlCastScalar) return this.toSQLScalar(item);
@@ -142,7 +196,7 @@ var Column = class {
 	*/
 	fromDriver(value) {
 		if (value === null) return null;
-		if (!this.config.dimension) return this.fromDriverScalar(value);
+		if (!this.dimensions) return this.fromDriverScalar(value);
 		let arr;
 		if (typeof value === "string") arr = this.#parsePostgresArrayString(value);
 		else arr = value;
@@ -191,7 +245,7 @@ var Column = class {
 	* Helper to recursively process multi-dimensional arrays for fromDriver.
 	*/
 	#fromDriverArray(arr, dimIndex) {
-		if (dimIndex >= this.config.dimension.length - 1) return arr.map((item) => this.fromDriverScalar(item));
+		if (dimIndex >= this.dimensions.length - 1) return arr.map((item) => this.fromDriverScalar(item));
 		return arr.map((item) => this.#fromDriverArray(item, dimIndex + 1));
 	}
 	/**
@@ -325,4 +379,4 @@ var Column = class {
 	}
 };
 //#endregion
-export { Column, identity, notNull, primaryKey, unique };
+export { Column, Dimension, array, identity, notNull, primaryKey, tuple, unique };

package/dist/src/columns/enum.mjs

@@ -10,7 +10,7 @@ var EnumedColumn = class extends Column {
 		this.#enum = enm;
 	}
 	get sqlTypeScalar() {
-		return `"${this.#enum.schema}"."${this.#enum.name}"`;
+		return `"${this.#enum.schemaSql}"."${this.#enum.nameSql}"`;
 	}
 	get sqlCastScalar() {
 		return this.sqlTypeScalar;

package/dist/src/constraints/check.d.mts

@@ -13,7 +13,7 @@ type CheckExpression<TScopeColumns extends TableAnyColumn> = Filter<TScopeColumn
 declare class Check {
   #private;
   constructor(name: string, expr: AnyFilter | Sql);
-  /** Returns the constraint name, appending `_check` suffix if not already present. */
+  /** Returns the constraint name as-is. */
   getName(): string;
   /**
    * Renders the constraint expression to a SQL string.

package/dist/src/constraints/check.mjs

@@ -9,9 +9,9 @@ var Check = class {
 		this.#name = name;
 		this.#expr = expr;
 	}
-	/** Returns the constraint name, appending `_check` suffix if not already present. */
+	/** Returns the constraint name as-is. */
 	getName() {
-		return this.#name.includes("check") ? this.#name : `${this.#name}_check`;
+		return this.#name;
 	}
 	/**
 	* Renders the constraint expression to a SQL string.
@@ -25,7 +25,20 @@ var Check = class {
 		return query.sql;
 	}
 };
-/** Creates a {@link Check} constraint from a filter expression or raw SQL. */
+/**
+* Creates a {@link Check} constraint from a filter expression or raw SQL.
+*
+* Convention: `check_<table>_<col>[_and_<col>]*[_<suffix>]?`
+*
+* @example
+* ```ts
+* table("public", "projects", { name: varchar({ length: 255 }) }, {
+*   checkConstraints: (t, check) => [
+*     check("check_projects_name_length", gte(sql`char_length(${t.name})`, 1)),
+*   ],
+* });
+* ```
+*/
 function check(name, expr) {
 	return new Check(name, expr);
 }

package/dist/src/constraints/primary-key.d.mts

@@ -1,10 +1,11 @@
-import { StdTable, StdTableColumn } from "../table.mjs";
+import { StdTableColumn } from "../table.mjs";
 
 //#region src/constraints/primary-key.d.ts
 declare class PrimaryKeyConstraint {
   #private;
   constructor(name: string, columns: StdTableColumn[]);
-  getName(table: StdTable): string;
+  /** Returns the constraint name as-is. */
+  getName(): string;
   getColumns(): string[];
 }
 /**
@@ -14,11 +15,13 @@ declare class PrimaryKeyConstraint {
  *
  * This function is passed as the second parameter to the `primaryKeyConstraint` callback.
  *
+ * Convention: `pk_<table>`
+ *
  * @example
  * ```ts
- * table("public", "user_roles", { userId: bigint({}), roleId: bigint({}) }, {
+ * table("public", "userRoles", { userId: bigint({}), roleId: bigint({}) }, {
  *   primaryKeyConstraint: (t, primaryKey) =>
- *     primaryKey("pk", [t.userId, t.roleId]),
+ *     primaryKey("pk_user_roles", [t.userId, t.roleId]),
  * });
  * ```
  */

package/dist/src/constraints/primary-key.mjs

@@ -7,8 +7,9 @@ var PrimaryKeyConstraint = class {
 		this.#name = name;
 		this.#columns = columns;
 	}
-	getName(table) {
-		return this.#name.startsWith(`${table._.name}_`) ? this.#name : `${table._.name}_${this.#name}`;
+	/** Returns the constraint name as-is. */
+	getName() {
+		return this.#name;
 	}
 	getColumns() {
 		return this.#columns.map((col) => col.nameSql);
@@ -21,11 +22,13 @@ var PrimaryKeyConstraint = class {
 *
 * This function is passed as the second parameter to the `primaryKeyConstraint` callback.
 *
+* Convention: `pk_<table>`
+*
 * @example
 * ```ts
-* table("public", "user_roles", { userId: bigint({}), roleId: bigint({}) }, {
+* table("public", "userRoles", { userId: bigint({}), roleId: bigint({}) }, {
 *   primaryKeyConstraint: (t, primaryKey) =>
-*     primaryKey("pk", [t.userId, t.roleId]),
+*     primaryKey("pk_user_roles", [t.userId, t.roleId]),
 * });
 * ```
 */

package/dist/src/constraints/unique.d.mts

@@ -1,11 +1,11 @@
-import { Key } from "../types.mjs";
-import { AnyColumn, StdTable, TableColumn } from "../table.mjs";
+import { StdTableColumn } from "../table.mjs";
 
 //#region src/constraints/unique.d.ts
 declare class UniqueConstraint {
   #private;
-  constructor(name: string, columns: TableColumn<string, string, Key, AnyColumn>[]);
-  getName(table: StdTable): string;
+  constructor(name: string, columns: StdTableColumn[]);
+  /** Returns the constraint name as-is. */
+  getName(): string;
   getColumns(): string[];
 }
 /**
@@ -14,16 +14,18 @@ declare class UniqueConstraint {
  *
  * This function is passed as the second parameter to the `uniqueConstraints` callback.
  *
+ * Convention: `unique_<table>_<col1>[_and_<col2>]*`
+ *
  * @example
  * ```ts
- * table("public", "user_roles", { userId: bigint({}), roleId: bigint({}) }, {
+ * table("public", "userRoles", { userId: bigint({}), roleId: bigint({}) }, {
  *   uniqueConstraints: (t, unique) => [
- *     unique("unique_user_role", [t.userId, t.roleId]),
+ *     unique("unique_user_roles_user_id_and_role_id", [t.userId, t.roleId]),
  *   ],
  * });
  * ```
  */
-declare function uniqueConstraint(name: string, columns: [TableColumn<string, string, Key, AnyColumn>, TableColumn<string, string, Key, AnyColumn>, ...TableColumn<string, string, Key, AnyColumn>[]]): UniqueConstraint;
+declare function uniqueConstraint(name: string, columns: [StdTableColumn, StdTableColumn, ...StdTableColumn[]]): UniqueConstraint;
 type UniqueConstraintFn = typeof uniqueConstraint;
 //#endregion
 export { UniqueConstraint, UniqueConstraintFn, uniqueConstraint };

package/dist/src/constraints/unique.mjs

@@ -7,8 +7,9 @@ var UniqueConstraint = class {
 		this.#name = name;
 		this.#columns = columns;
 	}
-	getName(table) {
-		return this.#name.startsWith(`${table._.name}_`) ? this.#name : `${table._.name}_${this.#name}`;
+	/** Returns the constraint name as-is. */
+	getName() {
+		return this.#name;
 	}
 	getColumns() {
 		return this.#columns.map((col) => col.nameSql);
@@ -20,11 +21,13 @@ var UniqueConstraint = class {
 *
 * This function is passed as the second parameter to the `uniqueConstraints` callback.
 *
+* Convention: `unique_<table>_<col1>[_and_<col2>]*`
+*
 * @example
 * ```ts
-* table("public", "user_roles", { userId: bigint({}), roleId: bigint({}) }, {
+* table("public", "userRoles", { userId: bigint({}), roleId: bigint({}) }, {
 *   uniqueConstraints: (t, unique) => [
-*     unique("unique_user_role", [t.userId, t.roleId]),
+*     unique("unique_user_roles_user_id_and_role_id", [t.userId, t.roleId]),
 *   ],
 * });
 * ```

package/dist/src/db.d.mts

@@ -1,4 +1,4 @@
-import { Valueof } from "./types.mjs";
+import { CamelToSnake, Valueof } from "./types.mjs";
 import { AnyColumn, AnyRelations, IsTableWC, Relations, TableWCorNever, TableWithColumns } from "./table.mjs";
 import { SelectBuilder } from "./query-builders/select.mjs";
 import { FilterExpression } from "./filters/index.mjs";
@@ -148,7 +148,7 @@ declare class Base<TTName extends string, TTables extends Record<TTName, TableWi
    * @param table The table to query — must have relations registered via `relations()`.
    * @returns A `RelationQueryBuilder` with `.findMany()` and `.findFirst()` methods.
    */
-  query<UTSchema extends string, UTName extends string, TColumns extends Record<string, AnyColumn>>(table: TableWithColumns<UTSchema, UTName, TColumns>): RelationQueryBuilder<UTSchema, UTName, TColumns, TAllRelations[`"${UTSchema}"."${UTName}"`], TAllRelations>;
+  query<UTSchema extends string, UTName extends string, TColumns extends Record<string, AnyColumn>>(table: TableWithColumns<UTSchema, UTName, TColumns>): RelationQueryBuilder<UTSchema, UTName, TColumns, TAllRelations[`"${CamelToSnake<UTSchema>}"."${CamelToSnake<UTName>}"`], TAllRelations>;
   /**
    * Execute a raw SQL query with optional parameter binding and custom result handler.
    * @param query The raw SQL query string with $1, $2, etc. placeholders for parameters

package/dist/src/enumtype.d.mts

@@ -1,15 +1,23 @@
+import { SnakeCase } from "./types.mjs";
 import { entityType } from "./symbols.mjs";
 import { EnumedColumn, EnumedConfig } from "./columns/enum.mjs";
 
 //#region src/enumtype.d.ts
+/** Represents a PostgreSQL enum type definition. */
 declare class Enum<U extends string = string, TValues extends Readonly<[U, ...U[]]> = Readonly<[U, ...U[]]>> {
-  #private;
   static readonly [entityType] = "Enum";
   readonly TValue: TValues[number];
+  /** The raw schema identifier as provided by the user (may be camelCase). */
+  readonly schema: string;
+  /** The snake_case version of {@link schema} used in generated SQL. */
+  readonly schemaSql: SnakeCase;
+  /** The raw enum name as provided by the user (may be camelCase). */
+  readonly name: string;
+  /** The snake_case version of {@link name} used in generated SQL. */
+  readonly nameSql: SnakeCase;
+  /** The ordered list of allowed enum values. */
+  readonly values: TValues;
   constructor(schema: string, name: string, values: TValues);
-  get schema(): string;
-  get name(): string;
-  get values(): TValues;
   enumed<TConfig extends EnumedConfig>(config: TConfig): EnumedColumn<TValues[number], TConfig>;
 }
 /**
@@ -19,7 +27,7 @@ declare class Enum<U extends string = string, TValues extends Readonly<[U, ...U[
  * ```ts
  * import { enumtype } from "durcno";
  *
- * export const UserTypeEnm = enumtype("public", "user_type", ["admin", "user"]);
+ * export const UserTypeEnm = enumtype("public", "userType", ["admin", "user"]);
  * ```
  */
 declare function enumtype<U extends string, TValues extends Readonly<[U, ...U[]]>>(schema: string, name: string, values: TValues): Enum<string, TValues>;

package/dist/src/enumtype.mjs

@@ -1,25 +1,27 @@
 import { entityType } from "./symbols.mjs";
+import { camelToSnake } from "./utils.mjs";
 import { enumed } from "./columns/enum.mjs";
 //#region src/enumtype.ts
+/** Represents a PostgreSQL enum type definition. */
 var Enum = class {
 	static [entityType] = "Enum";
 	TValue;
-	#schema;
-	#name;
-	#values;
+	/** The raw schema identifier as provided by the user (may be camelCase). */
+	schema;
+	/** The snake_case version of {@link schema} used in generated SQL. */
+	schemaSql;
+	/** The raw enum name as provided by the user (may be camelCase). */
+	name;
+	/** The snake_case version of {@link name} used in generated SQL. */
+	nameSql;
+	/** The ordered list of allowed enum values. */
+	values;
 	constructor(schema, name, values) {
-		this.#schema = schema;
-		this.#name = name;
-		this.#values = values;
-	}
-	get schema() {
-		return this.#schema;
-	}
-	get name() {
-		return this.#name;
-	}
-	get values() {
-		return this.#values;
+		this.schema = schema;
+		this.schemaSql = camelToSnake(schema);
+		this.name = name;
+		this.nameSql = camelToSnake(name);
+		this.values = values;
 	}
 	enumed(config) {
 		return enumed(this, config);
@@ -32,7 +34,7 @@ var Enum = class {
 * ```ts
 * import { enumtype } from "durcno";
 *
-* export const UserTypeEnm = enumtype("public", "user_type", ["admin", "user"]);
+* export const UserTypeEnm = enumtype("public", "userType", ["admin", "user"]);
 * ```
 */
 function enumtype(schema, name, values) {