@zerotal/orm 1.0.4 → 1.3.0

package/src/schema/Blueprint.ts

@@ -332,6 +332,19 @@ export class Blueprint {
     return this._add(new ColumnBuilder(name, "TEXT"));
   }
 
+  /**
+   * Alias of {@link Blueprint.dateTime}, spelled the way the column *type* is.
+   *
+   * The type string is lowercase (`@column({ type: "datetime" })`) while the builder
+   * method is camelCase, so reaching for `table.datetime(...)` is the natural mistake —
+   * and the blueprint is loosely typed, so it surfaced as a `TypeError` mid-migration
+   * rather than a compile error.
+   * @category Column types
+   */
+  datetime(name: string): ColumnBuilder {
+    return this.dateTime(name);
+  }
+
   /**
    * Timestamp column. Alias of {@link Blueprint.dateTime} — stored as `TEXT` (ISO-8601).
    * @category Column types

package/src/schema/MigrationCodegen.ts

@@ -6,12 +6,23 @@ import { columnDbName, type ModelColumn, type ModelSchema } from "./ModelInspect
 // Maps @column({ type }) to the Blueprint method that generates the right SQL.
 const BLUEPRINT_METHOD: Record<string, string> = {
   string: "string",
+  text: "text",
   number: "integer",
   boolean: "boolean",
   datetime: "dateTime",
   json: "json",
 };
 
+/**
+ * A column named `*_id` (or `*Id` before snake-casing) is a foreign key by convention,
+ * and an unindexed foreign key is a table scan on every join and every cascade check.
+ * The reference itself can't always be inferred — the target table is a guess — but the
+ * index can, and it is the half that matters for performance.
+ */
+function _looksLikeForeignKey(dbName: string): boolean {
+  return dbName.endsWith("_id") && dbName !== "_id";
+}
+
 // ── Code generation helpers ───────────────────────────────────────────────────
 
 function blueprintCall(col: ModelColumn, indent: string): string {
@@ -23,6 +34,26 @@ function blueprintCall(col: ModelColumn, indent: string): string {
   return line;
 }
 
+/**
+ * The index lines for a table: everything declared via `@column({ unique | index })`,
+ * plus an inferred index on each foreign-key-shaped column that doesn't already have one.
+ */
+function indexLines(columns: ModelColumn[], indent: string): string[] {
+  const lines: string[] = [];
+  for (const col of columns) {
+    if (col.primary) continue; // the PK is already indexed by increments()
+    const dbName = columnDbName(col.name);
+    if (col.unique) {
+      lines.push(`${indent}table.unique('${dbName}');`);
+    } else if (col.index) {
+      lines.push(`${indent}table.index('${dbName}');`);
+    } else if (_looksLikeForeignKey(dbName)) {
+      lines.push(`${indent}table.index('${dbName}');`);
+    }
+  }
+  return lines;
+}
+
 function createTableBlock(schema: ModelSchema): string {
   const lines: string[] = [];
   lines.push(`    await Schema.create('${schema.table}', (table) => {`);
@@ -36,6 +67,8 @@ function createTableBlock(schema: ModelSchema): string {
   if (schema.timestamps) lines.push("      table.timestamps();");
   if (schema.softDeletes) lines.push("      table.softDeletes();");
 
+  lines.push(...indexLines(schema.columns, "      "));
+
   lines.push("    });");
   return lines.join("\n");
 }
@@ -57,6 +90,12 @@ function alterTableBlocks(newColumns: NewColumn[]): string {
     const lines: string[] = [];
     lines.push(`    await Schema.table('${table}', (table) => {`);
     for (const nc of cols) lines.push(blueprintCall(nc.column, "      "));
+    lines.push(
+      ...indexLines(
+        cols.map((nc) => nc.column),
+        "      ",
+      ),
+    );
     lines.push("    });");
     blocks.push(lines.join("\n"));
   }

package/src/schema/ModelInspector.ts

@@ -6,10 +6,14 @@ import { columnRegistry, columnsFor } from "../model/decorators/_metadata.ts";
 
 export interface ModelColumn {
   name: string;
-  type: ColumnOptions["type"]; // 'string' | 'number' | 'boolean' | 'datetime' | 'json'
+  type: ColumnOptions["type"]; // 'string' | 'text' | 'number' | 'boolean' | 'datetime' | 'json'
   nullable: boolean;
   primary: boolean;
   default: unknown;
+  /** `@column({ unique: true })` — emit a unique index for this column. */
+  unique?: boolean;
+  /** `@column({ index: true })` — emit a plain index for this column. */
+  index?: boolean;
 }
 
 export interface ModelSchema {
@@ -59,6 +63,8 @@ function toModelColumns(fields: Map<string, ColumnOptions>): ModelColumn[] {
       nullable: opts.nullable ?? false,
       primary: opts.primary ?? false,
       default: opts.default,
+      unique: opts.unique ?? false,
+      index: opts.index ?? false,
     });
   }
   return columns;

package/src/schema/Schema.ts

@@ -101,6 +101,19 @@ export const Schema = {
     }
   },
 
+  /**
+   * Alias of {@link Schema.table}, for modifying an existing table.
+   *
+   * `alter` is the name Laravel and Knex use, so it is the first thing reached for — and
+   * because the blueprint callback is loosely typed, `Schema.alter(...)` was not a type
+   * error, only a `TypeError` at run time. A migration that fails there has already run
+   * whatever statements preceded it, leaving the schema half-changed, which is a worse
+   * outcome than one that never starts.
+   */
+  async alter(name: string, callback: (bp: Blueprint) => void): Promise<void> {
+    await Schema.table(name, callback);
+  },
+
   /** `DROP TABLE table_name` */
   async drop(table: string): Promise<void> {
     await ddl(`DROP TABLE ${table}`);

package/src/schema/autoMigrate.ts

@@ -9,6 +9,7 @@ import type { ModelColumn } from "./ModelInspector.ts";
 // `migrate:generate` would - but applies it directly instead of writing a migration file.
 const BLUEPRINT_METHOD: Record<string, string> = {
   string: "string",
+  text: "text",
   number: "integer",
   boolean: "boolean",
   datetime: "dateTime",
@@ -21,15 +22,22 @@ type TableBuilder = Record<string, (name: string) => ColumnBuilder> & {
   timestamps(): void;
   softDeletes(): void;
   dropColumn(...names: string[]): unknown;
+  unique(columns: string | string[], name?: string): unknown;
+  index(columns: string | string[], name?: string): unknown;
 };
 
 function applyColumn(table: TableBuilder, col: ModelColumn): void {
   const method = BLUEPRINT_METHOD[col.type ?? "string"] ?? "string";
   // Models declare columns in camelCase; the ORM reads/writes snake_case — emit snake_case
   // so synchronize produces columns the runtime can actually read (e.g. two_factor_secret).
-  const builder = table[method]!(columnDbName(col.name));
+  const dbName = columnDbName(col.name);
+  const builder = table[method]!(dbName);
   if (col.nullable) builder.nullable();
   if (col.default !== undefined) builder.default(col.default);
+  // Declared constraints travel with the column, so a synced schema carries the same
+  // uniqueness guarantee the model asserts rather than only the column's storage type.
+  if (col.unique) table.unique(dbName);
+  else if (col.index) table.index(dbName);
 }
 
 /** Options for {@link synchronizeSchema}. */