@c9up/atlas 0.1.3 → 0.1.5

package/src/BaseRepository.ts

@@ -120,6 +120,39 @@ export interface DatabaseConnection {
 
 // ─── Repository ─────────────────────────────────────────────
 
+/** Logical column types Postgres won't coerce from a text-bound param. */
+const POSTGRES_CAST_TYPES = new Set([
+	"timestamp",
+	"datetime",
+	"date",
+	"time",
+	"uuid",
+	"json",
+	"jsonb",
+]);
+
+/**
+ * Snake column → logical type for params needing a Postgres `$N::<type>` cast.
+ * sqlx binds JS strings as `text`; Postgres won't implicitly coerce that to
+ * timestamp/uuid/date. The Rust compiler applies these on Postgres only.
+ */
+function computeCastTypes(
+	entityClass: Parameters<typeof getColumnMetadata>[0],
+): Record<string, string> {
+	const out: Record<string, string> = {};
+	for (const col of getColumnMetadata(entityClass)) {
+		const t = col.type?.toLowerCase();
+		if (t && POSTGRES_CAST_TYPES.has(t)) {
+			out[camelToSnake(col.propertyKey)] = t;
+		}
+	}
+	// A uuid-strategy primary key is generated app-side as a string.
+	if (getPrimaryKeyGenerator(entityClass) === "uuid") {
+		out[camelToSnake(getPrimaryKey(entityClass) ?? "id")] ??= "uuid";
+	}
+	return out;
+}
+
 export class BaseRepository<T extends BaseEntity> {
 	#entityClass: EntityConstructor<T>;
 	#tableName: string;
@@ -130,6 +163,8 @@ export class BaseRepository<T extends BaseEntity> {
 	#validColumns: Set<string>;
 	#columnMap: Map<string, string>; // camelCase → snake_case (cached)
 	#dateColumns: Record<string, DateColumnConfig>;
+	/** Snake column → logical type for params needing a Postgres `::cast`. */
+	#castTypes: Record<string, string>;
 	/**
 	 * Per-property `prepare` (model → DB) callbacks lifted directly from
 	 * `@Column({ prepare })` metadata. Keyed by camelCase `propertyKey`.
@@ -214,6 +249,10 @@ export class BaseRepository<T extends BaseEntity> {
 		this.#validColumns.add(this.#primaryKey);
 		this.#validColumns.add(camelToSnake(this.#primaryKey));
 		this.#columnMap.set(this.#primaryKey, camelToSnake(this.#primaryKey));
+
+		// Postgres cast hints: sqlx binds JS strings as `text`, which Postgres
+		// won't coerce to timestamp/uuid/date. See `computeCastTypes`.
+		this.#castTypes = computeCastTypes(entityClass);
 	}
 
 	// ─── Column validation ────────────────────────────────────
@@ -470,6 +509,7 @@ export class BaseRepository<T extends BaseEntity> {
 				kind: "insert",
 				table: this.#tableName,
 				rows: specRows,
+				casts: this.#castTypes,
 				returning: [
 					camelToSnake(this.#primaryKey),
 					...this.#columns.map((c) => camelToSnake(c)),
@@ -549,6 +589,7 @@ export class BaseRepository<T extends BaseEntity> {
 			rows,
 			conflictColumns: conflictColumns.map((c) => this.#resolveColumn(c)),
 			updateColumns: updateColumns.map((c) => this.#resolveColumn(c)),
+			casts: this.#castTypes,
 		};
 		const compiled = compileStatementNative(spec, this.#dialect);
 		const result = await this.#db.execute(
@@ -860,7 +901,13 @@ export class BaseRepository<T extends BaseEntity> {
 	): Promise<void> {
 		if (set.length === 0) return;
 		const compiled = compileStatementNative(
-			{ kind: "update", table: this.#tableName, set, wheres },
+			{
+				kind: "update",
+				table: this.#tableName,
+				set,
+				wheres,
+				casts: this.#castTypes,
+			},
 			this.#dialect,
 		);
 		await this.#db.execute(compiled.statements[0], compiled.params);
@@ -880,12 +927,18 @@ export class BaseRepository<T extends BaseEntity> {
 					kind: "insert",
 					table: this.#tableName,
 					values,
+					casts: this.#castTypes,
 					returning: [
 						camelToSnake(this.#primaryKey),
 						...this.#columns.map((c) => camelToSnake(c)),
 					],
 				}
-			: { kind: "insert", table: this.#tableName, values };
+			: {
+					kind: "insert",
+					table: this.#tableName,
+					values,
+					casts: this.#castTypes,
+				};
 		const compiled = compileStatementNative(spec, this.#dialect);
 		if (supportsReturning) {
 			const rows = await this.#db.query<Row>(
@@ -1325,14 +1378,6 @@ export class BaseRepository<T extends BaseEntity> {
 			const tsConfig = pivot.pivotTimestamps;
 			const pivotAdapters = pivot.pivotColumnAdapters;
 			const dialect = this.#dialect;
-			// Validated quote: allow only `[A-Za-z0-9_]` so a malicious metadata
-			// value never breaks out of the identifier. Anything else throws.
-			const quote = (name: string): string => {
-				if (!/^[A-Za-z0-9_]+$/.test(name)) {
-					throw new Error(`Unsafe identifier in pivot metadata: '${name}'`);
-				}
-				return dialect === "mysql" ? `\`${name}\`` : `"${name}"`;
-			};
 
 			/**
 			 * Resolve pivot timestamp column names from the decorator config.
@@ -1496,7 +1541,24 @@ export class BaseRepository<T extends BaseEntity> {
 					for (const [k, v] of Object.entries(ts)) pairs.push([k, v]);
 					return pairs;
 				});
-				const spec = { kind: "insert", table: pivotTable, rows: rowPairs };
+				// Postgres casts for the pivot row: the two FK columns reference the
+				// parent / related PK types (often uuid), and pivot timestamps are
+				// bound strings — all need `$N::<type>` on Postgres.
+				const pivotCasts: Record<string, string> = {};
+				const parentPkCast = this.#castTypes[camelToSnake(this.#primaryKey)];
+				if (parentPkCast) pivotCasts[pivotFk] = parentPkCast;
+				const relatedPkCast =
+					computeCastTypes(relatedClass)[
+						camelToSnake(getPrimaryKey(relatedClass) ?? "id")
+					];
+				if (relatedPkCast) pivotCasts[pivotOther] = relatedPkCast;
+				for (const k of Object.keys(ts)) pivotCasts[k] = "timestamp";
+				const spec = {
+					kind: "insert",
+					table: pivotTable,
+					rows: rowPairs,
+					casts: pivotCasts,
+				};
 				const compiled = compileStatementNative(spec, dialect);
 				await db.execute(compiled.statements[0], compiled.params);
 			};

package/src/adapters/NapiDbAdapter.ts

@@ -22,7 +22,7 @@ export interface AsyncDatabaseConnection {
 	/**
 	 * Run every statement in `batch` atomically inside a single sqlx transaction.
 	 * Either every statement commits or none do — used by MigrationRunner to
-	 * wrap `up()` / `down()` SQL together with the `_migrations` bookkeeping.
+	 * wrap `up()` / `down()` SQL together with the `ream_migrations` bookkeeping.
 	 */
 	runInTransaction(batch: readonly BatchStatement[]): Promise<number>;
 	close(): Promise<void>;

package/src/schema/MigrationRunner.ts

@@ -16,7 +16,7 @@ import {
 } from "../utils/safePath.js";
 import type { Migration } from "./Migration.js";
 
-const DEFAULT_TABLE = "_migrations";
+const DEFAULT_TABLE = "ream_migrations";
 const TABLE_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 function validateTrackingTableName(name: string): string {
@@ -99,26 +99,26 @@ export class MigrationRunner {
 	 * @param options.migrationsDir Directory containing migration files. Defaults to `database/migrations`.
 	 * @param options.dialect SQL dialect of the adapter. Defaults to `sqlite`.
 	 * @param options.tableName Custom name for the migrations tracking table.
-	 *   Defaults to `"_migrations"`. Must match `/^[A-Za-z_][A-Za-z0-9_]*$/` —
+	 *   Defaults to `"ream_migrations"`. Must match `/^[A-Za-z_][A-Za-z0-9_]*$/` —
 	 *   throws `AtlasError("MIGRATION_INVALID_TABLE_NAME")` synchronously otherwise.
 	 *
 	 *   Cleanup coupling: `DatabaseCleanup.truncateAll` (`src/testing/DatabaseCleanup.ts`)
-	 *   skips tables whose name starts with a literal `_` (via `LIKE '\_%' ESCAPE '\'`).
-	 *   The default `"_migrations"` is therefore auto-protected. Choosing a non-`_`
-	 *   prefix (e.g. `"schema_versions"`) opts the tracking table out of that
-	 *   protection — `truncateAll` will wipe it alongside user tables, forcing a
-	 *   re-`init()` and replay of every migration on next test run.
+	 *   skips tables whose name starts with `ream_` (via `LIKE 'ream\_%' ESCAPE '\'`).
+	 *   The default `"ream_migrations"` is therefore auto-protected. Choosing a name
+	 *   without the `ream_` prefix (e.g. `"schema_versions"`) opts the tracking table
+	 *   out of that protection — `truncateAll` will wipe it alongside user tables,
+	 *   forcing a re-`init()` and replay of every migration on next test run.
 	 *
 	 *   Rename caveat: `init()` emits `CREATE TABLE IF NOT EXISTS <tableName>` —
 	 *   it does NOT auto-migrate from a previous tracking table. A project that
-	 *   has been running with `_migrations` and then changes `tableName` to
+	 *   has been running with `ream_migrations` and then changes `tableName` to
 	 *   `schema_versions` will get a fresh empty `schema_versions` on next boot,
 	 *   read zero applied migrations, and re-run every past migration (likely
 	 *   crashing on `CREATE TABLE <user-table>` already-exists). To rename
 	 *   safely, copy the history manually before switching:
 	 *
-	 *     INSERT INTO schema_versions SELECT * FROM _migrations;
-	 *     -- (then DROP TABLE _migrations once verified)
+	 *     INSERT INTO schema_versions SELECT * FROM ream_migrations;
+	 *     -- (then DROP TABLE ream_migrations once verified)
 	 */
 	constructor(
 		db: DatabaseAdapter,
@@ -137,16 +137,20 @@ export class MigrationRunner {
 				: validateTrackingTableName(options.tableName);
 	}
 
-	/** Ensure the _migrations tracking table exists. */
+	/** Ensure the ream_migrations tracking table exists. */
 	async init(): Promise<void> {
 		await runStmt(this.#db, this.#dialect, {
 			kind: "createTable",
 			table: this.#tableName,
 			ifNotExists: true,
 			columns: [
+				// Auto-increment PK (Lucid's adonis_schema uses `increments`). The
+				// Rust compiler emits the dialect-appropriate identity clause, so
+				// the INSERT below omits `id` on every dialect.
 				{
 					name: "id",
 					kind: "integer",
+					autoIncrement: true,
 					nullable: false,
 					primary: true,
 					unique: false,
@@ -257,7 +261,7 @@ export class MigrationRunner {
 			const migration = await this.#loadMigration(name);
 			const statements = await migration.getUpSQL();
 
-			// Compile the _migrations INSERT so we can include it in the same
+			// Compile the ream_migrations INSERT so we can include it in the same
 			// transaction as the migration's own DDL/DML — either everything
 			// commits or nothing does.
 			const insertCompiled = compileStatementNative(

package/src/schema/TableBuilder.ts

@@ -36,6 +36,21 @@ export class TableBuilder {
 		return this.#addColumn(name, "uuid");
 	}
 
+	/**
+	 * Auto-incrementing integer primary key (Lucid `increments()`). The Rust
+	 * compiler emits the dialect-appropriate identity clause (SQLite
+	 * `AUTOINCREMENT`, Postgres `GENERATED ... AS IDENTITY`, MySQL
+	 * `AUTO_INCREMENT`). For a 64-bit key use `bigIncrements()`.
+	 */
+	increments(name = "id"): this {
+		return this.#addIncrements(name, "integer");
+	}
+
+	/** Auto-incrementing 64-bit primary key (Lucid `bigIncrements()`). */
+	bigIncrements(name = "id"): this {
+		return this.#addIncrements(name, "bigInteger");
+	}
+
 	string(name: string, length = 255): this {
 		this.#addColumn(name, "string");
 		if (this.#currentColumn) this.#currentColumn.length = length;
@@ -209,6 +224,7 @@ export class TableBuilder {
 				scale: c.scale ?? null,
 				nullable: c.nullable,
 				primary: c.primary,
+				autoIncrement: c.autoIncrement ?? false,
 				unique: c.unique,
 				default: c.defaultValue ?? null,
 				references: c.references ?? null,
@@ -235,4 +251,14 @@ export class TableBuilder {
 		this.#currentColumn = col;
 		return this;
 	}
+
+	#addIncrements(name: string, type: "integer" | "bigInteger"): this {
+		this.#addColumn(name, type);
+		if (this.#currentColumn) {
+			this.#currentColumn.autoIncrement = true;
+			this.#currentColumn.primary = true;
+			this.#currentColumn.nullable = false;
+		}
+		return this;
+	}
 }

package/src/schema/types.ts

@@ -39,6 +39,8 @@ export interface ColumnDefinition {
 	scale?: number;
 	nullable: boolean;
 	primary: boolean;
+	/** Dialect-appropriate auto-increment / identity column (Lucid `increments`). Implies primary key. */
+	autoIncrement?: boolean;
 	unique: boolean;
 	defaultValue?: string;
 	references?: { table: string; column: string };

package/src/testing/DatabaseCleanup.ts

@@ -21,20 +21,19 @@ export async function useTransaction(
 }
 
 /**
- * Truncate all user tables (excludes _migrations and internal tables).
+ * Truncate all user tables (excludes ream_* framework tables and SQLite internals).
  *
  * The SELECT on `sqlite_master` is SQLite-specific introspection and is kept
  * as raw SQL intentionally — it's not a user query. The resulting DELETEs
  * go through the Rust compiler.
  */
 export async function truncateAll(db: AsyncDatabaseConnection): Promise<void> {
-	// SQL LIKE `_` is a single-char wildcard, not a literal underscore.
-	// `NOT LIKE '_%'` without `ESCAPE` matches NOTHING (every non-empty name
-	// matches `_%`). The `ESCAPE '\'` clause makes `\_` a literal underscore,
-	// so the exclusion targets only names starting with `_` (the convention
-	// for framework-private tables, including `_migrations`).
+	// SQL LIKE `_` is a single-char wildcard, not a literal underscore, so the
+	// `ESCAPE '\'` clause makes `\_` a literal underscore. The exclusion targets
+	// names starting with `ream_` (the convention for framework-private tables,
+	// including `ream_migrations`) and SQLite's own `sqlite_%` tables.
 	const tables = await db.query(
-		"SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '\\_%' ESCAPE '\\' AND name NOT LIKE 'sqlite_%'",
+		"SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'ream\\_%' ESCAPE '\\' AND name NOT LIKE 'sqlite_%'",
 	);
 	const dialect = getAtlasDialect();
 	for (const row of tables) {