@c9up/atlas 0.3.5 → 0.3.7

package/src/console/migrationCommands.ts

@@ -61,6 +61,18 @@ export interface MigrationCommandOptions {
 	 * loads it once migrations exist.
 	 */
 	schemaPath?: string;
+	/**
+	 * Migration bookkeeping table — Adonis Lucid `migrations.tableName`. Must
+	 * match what the application boots with: a command tracking migrations in a
+	 * different table than the app would re-apply every migration it cannot see.
+	 * Defaults to the runner's `"ream_migrations"`.
+	 */
+	tableName?: string;
+	/**
+	 * Refuse rollback/reset/refresh/fresh/wipe in production unless `--force`
+	 * (Adonis Lucid `migrations.disableRollbacksInProduction`). On by default.
+	 */
+	disableRollbacksInProduction?: boolean;
 }
 
 /**
@@ -105,6 +117,11 @@ function resolveRunner(
 		dialect: db.dialect,
 		naturalSort: options.naturalSort,
 		disableTransactions: options.disableTransactions,
+		// Without the table name the runner falls back to its default while the
+		// application tracks migrations in the configured one — the command would
+		// then see an empty history and re-apply everything.
+		tableName: options.tableName,
+		disableRollbacksInProduction: options.disableRollbacksInProduction,
 	});
 }
 

package/src/console/schemaCheckCommand.ts

@@ -21,10 +21,12 @@ type Constructor = new (...args: unknown[]) => unknown;
 export type { AtlasCommandClass } from "./contract.js";
 
 /**
- * Build the `atlas:check` command for the given models. Register it in
- * `reamrc.commands` (atlas has no global entity registry — list your models,
- * as in Lucid). Run it as `ream atlas:check`; `--warn` reports drift without a
- * non-zero exit (useful for an advisory CI step).
+ * Build the `atlas:check` command for the given models.
+ *
+ * Most applications do not call this: `@c9up/atlas/commands` ships the command
+ * already, reading the models from `verifySchema.entities`. Call it directly to
+ * verify a different set — pass a function when the list is only known once the
+ * application has booted.
  *
  * @example
  *   // commands/atlas-check.ts
@@ -35,7 +37,7 @@ export type { AtlasCommandClass } from "./contract.js";
  *   // run:  ream atlas:check --warn
  */
 export function schemaCheckCommand(
-	entities: readonly Constructor[],
+	entities: readonly Constructor[] | (() => readonly Constructor[]),
 ): AtlasCommandClass {
 	return class SchemaCheck {
 		static commandName = "atlas:check";
@@ -58,7 +60,18 @@ export function schemaCheckCommand(
 				process.exitCode = 1;
 				return;
 			}
-			const code = await runSchemaCheck(entities, db, getAtlasDialect());
+			// Resolved here, not at registration: the shipped command reads the
+			// models from `verifySchema.entities`, which only exists once the
+			// application has booted its config.
+			const models = typeof entities === "function" ? entities() : entities;
+			if (models.length === 0) {
+				console.error(
+					"[atlas:check] no models to verify — list them under `verifySchema.entities` in config/database.ts.",
+				);
+				process.exitCode = 1;
+				return;
+			}
+			const code = await runSchemaCheck(models, db, getAtlasDialect());
 			// `--warn` downgrades drift to advisory (exit 0); default fails CI.
 			if (code !== 0 && !this.warn) process.exitCode = code;
 		}

package/src/decorators/entity.ts

@@ -214,7 +214,7 @@ export function Entity(tableName: string): ClassDecorator {
 }
 
 /** @Column() — marks a property as a database column. */
-export function Column(options?: ColumnOptions): PropertyDecorator {
+function ColumnBase(options?: ColumnOptions): PropertyDecorator {
 	return (target, propertyKey) => {
 		const columns: ColumnMetadata[] =
 			Reflect.getOwnMetadata(COLUMNS_KEY, target.constructor) ?? [];
@@ -362,23 +362,64 @@ function columnDateTime(options?: DateTimeColumnOptions): PropertyDecorator {
 	};
 }
 
-/** Namespace access so users write `@column.date()` / `@column.dateTime()`. */
-const columnWithSubs = Column as typeof Column & {
-	date: typeof columnDate;
-	dateTime: typeof columnDateTime;
-};
-columnWithSubs.date = columnDate;
-columnWithSubs.dateTime = columnDateTime;
+/** Options for `@Column.json()`. */
+export interface JsonColumnOptions extends ColumnOptions {
+	/**
+	 * The SQL type the column is declared with. `jsonb` by default — the binary
+	 * form, which is what a Postgres schema almost always wants. Pass `'json'`
+	 * for the textual one.
+	 */
+	type?: "json" | "jsonb";
+}
 
 /**
- * `Column` exposed with its sub-decorators (`Column.date()`, `Column.dateTime()`).
- * Alias exports so TS users can `import { column } from '@c9up/atlas'` for a
- * Lucid-style lowercase naming when they prefer.
+ * `@Column.json()` — a column holding a JSON document.
+ *
+ * The property keeps its JavaScript shape on both sides: assign an object or an
+ * array, read an object or an array back. atlas serialises the value when it
+ * writes the row and parses it when it reads one, so nothing in the application
+ * converts by hand, and every dialect behaves the same — Postgres decodes JSON
+ * itself, while SQLite and MySQL store text.
+ *
+ *   @Column.json() declare metadata: Record<string, unknown> | null
+ *   @Column.json({ type: 'json' }) declare tags: string[] | null
+ *
+ * A `prepare` or `consume` given here still wins: the column is yours to
+ * encode differently when the document needs it.
+ *
+ * Declaring `@Column({ type: 'jsonb' })` does the same thing — the type is what
+ * atlas reads — but this says it in one place and cannot be mistyped.
  */
-export const column = Column as typeof Column & {
+function columnJson(options?: JsonColumnOptions): PropertyDecorator {
+	return (target, propertyKey) => {
+		Column({ ...options, type: options?.type ?? "jsonb" })(target, propertyKey);
+	};
+}
+
+/**
+ * `@Column()` with its sub-decorators attached: `Column.date()`,
+ * `Column.dateTime()`, `Column.json()`.
+ *
+ * The type carries them too — attaching them to the plain function left
+ * `Column.date` working at runtime but unknown to TypeScript, so only the
+ * lowercase alias type-checked.
+ */
+const ColumnWithSubs = ColumnBase as typeof ColumnBase & {
 	date: typeof columnDate;
 	dateTime: typeof columnDateTime;
+	json: typeof columnJson;
 };
+ColumnWithSubs.date = columnDate;
+ColumnWithSubs.dateTime = columnDateTime;
+ColumnWithSubs.json = columnJson;
+
+export const Column = ColumnWithSubs;
+
+/**
+ * Also exported lowercase, so `import { column } from '@c9up/atlas'` reads the
+ * way a schema definition usually does. The same decorator, either spelling.
+ */
+export const column = ColumnWithSubs;
 
 /** Read the date-column configuration map for an entity class (walks prototype chain). */
 export function getDateColumnConfig(

package/src/index.ts

@@ -72,6 +72,7 @@ export type {
 	DateColumnConfig,
 	DateTimeColumnOptions,
 	EntityMetadata,
+	JsonColumnOptions,
 	ManyToManyOptions,
 	RelationMetadata,
 } from "./decorators/entity.js";

package/src/services/db.ts

@@ -13,7 +13,10 @@
  * container hooks).
  */
 
-import type { ConnectionConfig } from "../AtlasProvider.js";
+import type {
+	AtlasDatabaseConfig,
+	ConnectionConfig,
+} from "../AtlasProvider.js";
 import type { AsyncDatabaseConnection } from "../adapters/NapiDbAdapter.js";
 import { ConnectionManager } from "../ConnectionManager.js";
 import {
@@ -171,6 +174,86 @@ export function getDb(): AsyncDatabaseConnection | undefined {
 	return instance;
 }
 
+// The config the provider booted with. Commands need it: `migration:run` has to
+// know where the migration files are, and Lucid answers that from the config
+// too (`connection.config.migrations.paths`, read through `lucid.db`). Atlas has
+// no framework container to read, so the provider records it here.
+let databaseConfig:
+	| { config: AtlasDatabaseConfig; defaultName: string }
+	| undefined;
+
+/** @internal Record the booted config (called by AtlasProvider). */
+export function setDatabaseConfig(
+	config: AtlasDatabaseConfig,
+	defaultName: string,
+): void {
+	databaseConfig = { config, defaultName };
+}
+
+/**
+ * @internal Forget the config IF it is still the one `config` describes.
+ * Ownership-guarded for the same reason {@link clearDb} is: a second provider
+ * may have rebound it, and the older provider's shutdown must not clear the
+ * newer binding.
+ */
+export function clearDatabaseConfig(config: AtlasDatabaseConfig): void {
+	if (databaseConfig?.config === config) databaseConfig = undefined;
+}
+
+/** The config the application booted with, or `undefined` before boot. */
+export function getDatabaseConfig(): AtlasDatabaseConfig | undefined {
+	return databaseConfig?.config;
+}
+
+/** The default connection's name — Lucid `db.primaryConnectionName`. */
+export function primaryConnectionName(): string {
+	return databaseConfig?.defaultName ?? "primary";
+}
+
+/**
+ * One connection's config, by name (default connection when unnamed).
+ *
+ * Read from the manager's node first — that is where Lucid keeps `migrations`,
+ * `seeders` and `schemaGeneration`, and the shape we mirror. The top level is
+ * the fallback, because the single-connection form IS the connection config,
+ * and because an app that set `migrations` there before these keys were
+ * per-connection must keep working.
+ */
+export function connectionConfigFor(name?: string): ConnectionConfig {
+	const resolved = name ?? primaryConnectionName();
+	const top = databaseConfig?.config;
+	// The manager knows a connection once the provider has registered it; before
+	// that — a command running against a config nobody opened yet — the declared
+	// `connections` entry is the same information.
+	const declared =
+		manager.get(resolved)?.config ?? top?.connections?.[resolved];
+	if (top === undefined) return declared ?? {};
+	if (declared === undefined) return top;
+	return {
+		...top,
+		...declared,
+		// These three are merged a level down rather than replaced: the top level
+		// is the single-connection form of the same config, so a connection that
+		// names only its paths must not drop a `tableName` set beside it.
+		migrations: mergeOrUndefined(top.migrations, declared.migrations),
+		seeders: mergeOrUndefined(top.seeders, declared.seeders),
+		schemaGeneration: mergeOrUndefined(
+			top.schemaGeneration,
+			declared.schemaGeneration,
+		),
+	};
+}
+
+/** `{...a, ...b}`, or `undefined` when neither side has anything to merge. */
+function mergeOrUndefined<T extends object>(
+	base: T | undefined,
+	override: T | undefined,
+): T | undefined {
+	if (base === undefined) return override;
+	if (override === undefined) return base;
+	return { ...base, ...override };
+}
+
 // The shared connection manager (Lucid `db.manager`) — the single owner of named
 // connections. Backs `BaseModel.connection = 'analytics'` so a model resolves a
 // non-default connection from a plain import (AdonisJS `static connection`).