@an5/orm 1.0.8 → 1.1.0

package/generator/src/parser.ts

@@ -1,202 +1,234 @@
-import fs from 'fs';
-import path from 'path';
-import { Model, Field, Relation } from './types';
-
-// SQL Server type → TypeScript type mapping
-const AN5_TO_TS: Record<string, string> = {
-  // String types
-  'NVARCHAR': 'string',
-  'VARCHAR': 'string',
-  'CHAR': 'string',
-  'NCHAR': 'string',
-  'TEXT': 'string',
-  'NTEXT': 'string',
-  'XML': 'string',
-  // Numeric types
-  'INT': 'number',
-  'SMALLINT': 'number',
-  'TINYINT': 'number',
-  'BIGINT': 'number | bigint',
-  'FLOAT': 'number',
-  'REAL': 'number',
-  'DECIMAL': 'number',
-  'NUMERIC': 'number',
-  'MONEY': 'number',
-  'SMALLMONEY': 'number',
-  // Boolean
-  'BIT': 'boolean',
-  // Date types
-  'DATETIME': 'Date',
-  'DATETIME2': 'Date',
-  'SMALLDATETIME': 'Date',
-  'DATE': 'Date',
-  'TIME': 'Date',
-  'DATETIMEOFFSET': 'Date',
-  // Binary types
-  'VARBINARY': 'Buffer',
-  'BINARY': 'Buffer',
-  'IMAGE': 'Buffer',
-  // Other
-  'UNIQUEIDENTIFIER': 'string',
-  'SQL_VARIANT': 'any',
-  'ROWVERSION': 'Buffer',
-  'HIERARCHYID': 'string',
-  'GEOGRAPHY': 'string',
-  'GEOMETRY': 'string',
-  'VECTOR': 'number[] | string',
-};
-
-// Parse base type from "NVARCHAR(255)" → "NVARCHAR"
-function parseSqlType(raw: string): { base: string; params: string } {
-  const match = raw.match(/^(\w+)(?:\((.+)\))?$/);
-  if (!match) return { base: raw, params: '' };
-  return { base: match[1].toUpperCase(), params: match[2] || '' };
-}
-
-// Map SQL Server type to TypeScript type
-export function sqlTypeToTs(sqlType: string): string {
-  const { base } = parseSqlType(sqlType);
-  return AN5_TO_TS[base] || 'any';
-}
-
-export class SchemaParser {
-  private schemaText: string = '';
-
-  constructor(private schemaDir: string) {}
-
-  public async parse(): Promise<Model[]> {
-    this.loadSchema();
-    const lines = this.schemaText.split('\n');
-    const models: Model[] = [];
-    let currentModel: Model | null = null;
-
-    for (let line of lines) {
-      line = line.trim();
-      if (!line || line.startsWith('//')) continue;
-
-      const modelHeaderMatch = line.match(/^model\s+(\w+)\s*\{/);
-      if (modelHeaderMatch) {
-        const modelName = modelHeaderMatch[1];
-        currentModel = {
-          name: modelName,
-          tableName: modelName.toLowerCase() + 's',
-          schemaName: 'dbo',
-          fields: [],
-          relations: []
-        };
-        models.push(currentModel);
-        continue;
-      }
-
-      if (line === '}') {
-        currentModel = null;
-        continue;
-      }
-
-      if (currentModel) {
-        this.parseModelLine(line, currentModel);
-      }
-    }
-
-    this.postProcessRelations(models);
-    return models;
-  }
-
-  private loadSchema() {
-    if (fs.existsSync(this.schemaDir)) {
-      const files = fs.readdirSync(this.schemaDir).filter(f => f.endsWith('.an5'));
-      for (const file of files) {
-        this.schemaText += fs.readFileSync(path.join(this.schemaDir, file), 'utf8') + '\n';
-      }
-    } else {
-      throw new Error(`No schema directory found at ${this.schemaDir}`);
-    }
-  }
-
-  private parseModelLine(line: string, model: Model) {
-    if (line.startsWith('@@map')) {
-      const mapMatch = line.match(/@@map\("(.+)"\)/);
-      if (mapMatch) model.tableName = mapMatch[1];
-      return;
-    }
-    if (line.startsWith('@@schema')) {
-      const schemaMatch = line.match(/@@schema\("(.+)"\)/);
-      if (schemaMatch) model.schemaName = schemaMatch[1];
-      return;
-    }
-    if (line.startsWith('@@unique')) {
-      const uniqueMatch = line.match(/@@unique\(\[([\w,\s]+)\]\)/);
-      if (uniqueMatch) {
-        const fields = uniqueMatch[1].split(',').map(f => f.trim());
-        model.compoundUniques = model.compoundUniques || [];
-        model.compoundUniques.push(fields);
-      }
-      return;
-    }
-    if (line.startsWith('@@description')) {
-      const descMatch = line.match(/@@description\("(.+)"\)/);
-      if (descMatch) model.description = descMatch[1];
-      return;
-    }
-    if (line.startsWith('@@')) return;
-
-    const parts = line.split(/\s+/);
-    const fieldName = parts[0];
-    let fieldType = parts[1];
-    if (!fieldName || !fieldType) return;
-
-    const isArray = fieldType.endsWith('[]');
-    const isOptional = fieldType.endsWith('?');
-    const cleanType = fieldType.replace('[]', '').replace('?', '');
-
-    // Parse SQL Server type (e.g., "NVARCHAR(255)" → base="NVARCHAR")
-    const { base: sqlBase } = parseSqlType(cleanType);
-
-    let tsType = 'any';
-    let isRelation = false;
-
-    // Check if it's a known SQL Server type
-    if (AN5_TO_TS[sqlBase]) {
-      tsType = sqlTypeToTs(cleanType);
-    } else if (cleanType[0] === cleanType[0].toUpperCase() && !cleanType.includes('(')) {
-      // Uppercase without parens = likely a relation to another model
-      tsType = cleanType;
-      isRelation = true;
-    }
-
-    if (isRelation) {
-      let foreignKey = '', localKey = '', relationName = '';
-      const nameMatch = line.match(/@relation\("(\w+)"/);
-      if (nameMatch) relationName = nameMatch[1];
-      const relationMatch = line.match(/@relation\((?:.*fields:\s*\[(\w+)\],)?\s*(?:.*references:\s*\[(\w+)\],?)?.*\)/);
-      if (relationMatch) {
-        foreignKey = relationMatch[1] || '';
-        localKey = relationMatch[2] || '';
-      }
-      model.relations.push({ name: fieldName, type: tsType, isArray, isOptional, foreignKey, localKey, relationName });
-    } else {
-      const hasDefault = line.includes('@default') || line.includes('@updatedAt') || line.includes('@id');
-      const isId = line.includes('@id');
-      let description: string | undefined;
-      const descMatch = line.match(/@description\("(.+)"\)/);
-      if (descMatch) description = descMatch[1];
-      model.fields.push({ name: fieldName, type: tsType, sqlType: cleanType, isOptional, hasDefault, isId, description });
-    }
-  }
-
-  private postProcessRelations(models: Model[]) {
-    for (const model of models) {
-      for (const rel of model.relations) {
-        if (!rel.foreignKey || !rel.localKey) {
-          const targetModel = models.find(m => m.name === rel.type);
-          if (targetModel) {
-            let opposite = rel.relationName ?
-              targetModel.relations.find(r => r.type === model.name && r.relationName === rel.relationName && r.foreignKey && r.localKey) :
-              targetModel.relations.find(r => r.type === model.name && r.foreignKey && r.localKey);
-            if (opposite) { rel.foreignKey = opposite.foreignKey; rel.localKey = opposite.localKey; }
-          }
-        }
-      }
-    }
-  }
-}
+import fs from 'fs';
+import path from 'path';
+import { Model, Field, Relation } from './types';
+import {
+  DEFAULT_PROVIDER,
+  FieldTypeError,
+  FieldTypeIssue,
+  Provider,
+  readFieldLineHead,
+  resolveFieldType,
+  unknownFieldTypeMessage,
+} from './field-types';
+
+/**
+ * Maps a column type of a provider to its TypeScript type.
+ *
+ * `provider` defaults to SQL Server so existing callers keep their behaviour;
+ * the generator passes the provider derived from the connection string.
+ */
+export function sqlTypeToTs(sqlType: string, provider: Provider = DEFAULT_PROVIDER): string {
+  return resolveFieldType(sqlType, provider)?.ts ?? 'any';
+}
+
+/**
+ * A field whose type is in no table for this provider. Whether it is a relation
+ * or a typo is not known yet, so the decision waits until the whole schema has
+ * been read.
+ */
+interface PendingModelRef {
+  model: Model;
+  name: string;
+  /** The name as written in the schema, kept verbatim to compare with model names. */
+  type: string;
+  isArray: boolean;
+  isOptional: boolean;
+  /** The original line, needed to read `@relation`/`@description`. */
+  line: string;
+}
+
+export class SchemaParser {
+  private schemaText: string = '';
+  private issues: FieldTypeIssue[] = [];
+  private modelRefs: PendingModelRef[] = [];
+  private models: Model[] = [];
+
+  /**
+   * @param schemaDir directory holding the `.an5` files
+   * @param provider target database; decides which field types are valid
+   */
+  constructor(
+    private schemaDir: string,
+    private provider: Provider = DEFAULT_PROVIDER,
+  ) {}
+
+  public async parse(): Promise<Model[]> {
+    this.issues = [];
+    this.modelRefs = [];
+    this.models = [];
+    this.loadSchema();
+    const lines = this.schemaText.split('\n');
+    const models: Model[] = [];
+    let currentModel: Model | null = null;
+
+    for (let line of lines) {
+      line = line.trim();
+      if (!line || line.startsWith('//')) continue;
+
+      const modelHeaderMatch = line.match(/^model\s+(\w+)\s*\{/);
+      if (modelHeaderMatch) {
+        const modelName = modelHeaderMatch[1];
+        currentModel = {
+          name: modelName,
+          tableName: modelName.toLowerCase() + 's',
+          // SQL Server's default schema, and only SQL Server's. For SQLite or MySQL
+          // an unqualified name is what the connection resolves, and for PostgreSQL
+          // it follows `search_path` — the same rule `db:push` now uses, so the
+          // generated client and the pushed table cannot drift apart.
+          schemaName: this.provider === 'mssql' ? 'dbo' : '',
+          provider: this.provider,
+          fields: [],
+          relations: []
+        };
+        models.push(currentModel);
+        continue;
+      }
+
+      if (line === '}') {
+        currentModel = null;
+        continue;
+      }
+
+      if (currentModel) {
+        this.parseModelLine(line, currentModel);
+      }
+    }
+
+    this.models = models;
+    this.resolveModelRefs();
+
+    // Every bad type is reported at once, so one pass over the schema is enough
+    // instead of re-running the generator after every line.
+    if (this.issues.length > 0) {
+      throw new FieldTypeError(this.provider, this.issues);
+    }
+
+    this.postProcessRelations(models);
+    return models;
+  }
+
+  private loadSchema() {
+    if (fs.existsSync(this.schemaDir)) {
+      const files = fs.readdirSync(this.schemaDir).filter(f => f.endsWith('.an5'));
+      for (const file of files) {
+        this.schemaText += fs.readFileSync(path.join(this.schemaDir, file), 'utf8') + '\n';
+      }
+    } else {
+      throw new Error(`No schema directory found at ${this.schemaDir}`);
+    }
+  }
+
+  private parseModelLine(line: string, model: Model) {
+    if (line.startsWith('@@map')) {
+      const mapMatch = line.match(/@@map\("(.+)"\)/);
+      if (mapMatch) model.tableName = mapMatch[1];
+      return;
+    }
+    if (line.startsWith('@@schema')) {
+      // `(.*)` rather than `(.+)`: `@@schema("")` is how a model says "no
+      // schema", needed for databases that have no schema concept. With `(.+)`
+      // the empty string does not match, the directive is silently ignored and
+      // the model keeps `dbo`.
+      const schemaMatch = line.match(/@@schema\("(.*)"\)/);
+      if (schemaMatch) model.schemaName = schemaMatch[1].trim();
+      return;
+    }
+    if (line.startsWith('@@unique')) {
+      const uniqueMatch = line.match(/@@unique\(\[([\w,\s]+)\]\)/);
+      if (uniqueMatch) {
+        const fields = uniqueMatch[1].split(',').map(f => f.trim());
+        model.compoundUniques = model.compoundUniques || [];
+        model.compoundUniques.push(fields);
+      }
+      return;
+    }
+    if (line.startsWith('@@description')) {
+      const descMatch = line.match(/@@description\("(.+)"\)/);
+      if (descMatch) model.description = descMatch[1];
+      return;
+    }
+    if (line.startsWith('@@')) return;
+
+    const head = readFieldLineHead(line);
+    if (!head) return;
+
+    // No table entry for this provider. This used to fall through to
+    // `tsType = 'any'` (or, worse, become a relation to a model that does not
+    // exist) and the client was still generated; the failure only surfaced
+    // later at the database layer, in a message unrelated to the schema.
+    const resolved = resolveFieldType(head.type, this.provider);
+    if (!resolved) {
+      this.modelRefs.push({ model, name: head.name, type: head.type, isArray: head.isArray, isOptional: head.isOptional, line });
+      return;
+    }
+
+    const hasDefault = line.includes('@default') || line.includes('@updatedAt') || line.includes('@id');
+    const isId = line.includes('@id');
+    let description: string | undefined;
+    const descMatch = line.match(/@description\("(.+)"\)/);
+    if (descMatch) description = descMatch[1];
+    model.fields.push({ name: head.name, type: resolved.ts, sqlType: head.type, isOptional: head.isOptional, hasDefault, isId, description });
+  }
+
+  /**
+   * Settles the fields that matched no type: a name matching a model in the
+   * schema is a relation, anything else is a bad type — reported with the
+   * provider name and a suggestion.
+   *
+   * The decision has to wait for the whole schema, because a relation may point
+   * at a model declared later. Every upper-case token used to count as a
+   * relation, so `INTEGER` written for SQL Server became a relation to a model
+   * named `INTEGER` and nothing ever complained.
+   */
+  private resolveModelRefs() {
+    const modelNames = this.models.map((model) => model.name);
+
+    for (const ref of this.modelRefs) {
+      if (!modelNames.includes(ref.type)) {
+        this.issues.push({
+          path: `${ref.model.name}.${ref.name}`,
+          message: unknownFieldTypeMessage(ref.type, this.provider, modelNames),
+        });
+        continue;
+      }
+
+      let foreignKey = '', localKey = '', relationName = '';
+      const nameMatch = ref.line.match(/@relation\("(\w+)"/);
+      if (nameMatch) relationName = nameMatch[1];
+      const relationMatch = ref.line.match(/@relation\((?:.*fields:\s*\[(\w+)\],)?\s*(?:.*references:\s*\[(\w+)\],?)?.*\)/);
+      if (relationMatch) {
+        foreignKey = relationMatch[1] || '';
+        localKey = relationMatch[2] || '';
+      }
+      const description = ref.line.match(/@description\("(.+)"\)/)?.[1];
+      ref.model.relations.push({
+        name: ref.name,
+        type: ref.type,
+        isArray: ref.isArray,
+        isOptional: ref.isOptional,
+        foreignKey,
+        localKey,
+        relationName,
+        ...(description ? { description } : {}),
+      });
+    }
+
+    this.modelRefs = [];
+  }
+
+  private postProcessRelations(models: Model[]) {
+    for (const model of models) {
+      for (const rel of model.relations) {
+        if (!rel.foreignKey || !rel.localKey) {
+          const targetModel = models.find(m => m.name === rel.type);
+          if (targetModel) {
+            let opposite = rel.relationName ?
+              targetModel.relations.find(r => r.type === model.name && r.relationName === rel.relationName && r.foreignKey && r.localKey) :
+              targetModel.relations.find(r => r.type === model.name && r.foreignKey && r.localKey);
+            if (opposite) { rel.foreignKey = opposite.foreignKey; rel.localKey = opposite.localKey; }
+          }
+        }
+      }
+    }
+  }
+}

package/generator/src/push-apply.ts

@@ -0,0 +1,148 @@
+/**
+ * Applying a schema to a database: what `db:push` does once the schema is read.
+ *
+ * Kept out of `push.ts` so the sequence can be run against a real database in a
+ * test — the CLI needs a live server, and a test that re-implements the sequence
+ * instead of calling it proves only that the copy works.
+ *
+ * The database is two functions rather than the adapter, which keeps this testable
+ * and keeps the driver out of the decision making.
+ */
+import { PushDialect } from './dialect';
+import { PushIndex, PushModel, directiveName, qualifiedTableName, safeIdentifierName } from './push-schema';
+
+/** The two things this needs from a database connection. */
+export interface PushDatabase {
+  /** Runs a query and returns its rows; existence checks are `length > 0`. */
+  query(sql: string): Promise<readonly unknown[]>;
+  /** Runs one statement. */
+  execute(sql: string): Promise<void>;
+  /** Progress, so the CLI prints what it is doing. */
+  log(message: string): void;
+}
+
+export interface ApplyResult {
+  /** How many tables were created, and how many altered. */
+  tablesCreated: number;
+  tablesAltered: number;
+  columnsAdded: number;
+  indexesCreated: number;
+  uniqueConstraintsAdded: number;
+}
+
+/**
+ * Creates whatever the schema has and the database does not.
+ *
+ * The order is deliberate: a table first, then missing columns, then unique
+ * constraints and indexes — a unique over a column that does not exist yet fails.
+ * Everything is checked before it is created, so running it twice changes nothing.
+ */
+export async function applySchema(
+  models: readonly PushModel[],
+  dialect: PushDialect,
+  db: PushDatabase,
+): Promise<ApplyResult> {
+  const result: ApplyResult = {
+    tablesCreated: 0,
+    tablesAltered: 0,
+    columnsAdded: 0,
+    indexesCreated: 0,
+    uniqueConstraintsAdded: 0,
+  };
+
+  for (const model of models) {
+    const tableName = qualifiedTableName(model);
+    const sqlTableName = dialect.quoteTable(tableName);
+    const quoteFields = (fields: readonly string[]) => fields.map((field) => dialect.quote(field));
+    db.log(`Processing table ${sqlTableName}...`);
+
+    const safeName = safeIdentifierName(model.tableName);
+    // SQLite has no named unique constraints — a UNIQUE there becomes an index the
+    // engine names itself — so the unique index carries our name instead, and that
+    // name is what the existence check can look for.
+    const compoundUniques = model.compoundUniques.map((directive, idx) => ({
+      name: directiveName(directive, model.tableName, 'compound', idx),
+      fields: directive.fields,
+      directive,
+    }));
+
+    const tableExists = (await db.query(dialect.tableExists(tableName))).length > 0;
+
+    if (!tableExists) {
+      db.log(`Creating table ${sqlTableName}...`);
+      const columnDefs = model.fields.map((field) => dialect.columnDefinition(field));
+      for (const entry of compoundUniques) {
+        if (!dialect.supportsNamedUniqueConstraint) continue;
+        const fieldsStr = quoteFields(entry.fields).join(', ');
+        columnDefs.push(`CONSTRAINT ${dialect.quote(entry.name)} UNIQUE (${fieldsStr})`);
+      }
+      await db.execute(dialect.createTable(sqlTableName, columnDefs));
+      db.log(`✅ Table ${sqlTableName} created.`);
+      result.tablesCreated += 1;
+    } else {
+      for (const field of model.fields) {
+        const columnExists = (await db.query(dialect.columnExists(tableName, field.name))).length > 0;
+        if (columnExists) continue;
+        db.log(`Adding column ${dialect.quote(field.name)} to table ${sqlTableName}...`);
+        await db.execute(dialect.addColumn(sqlTableName, field));
+        result.columnsAdded += 1;
+        // A new `@unique` column needs its unique too, and on SQLite that cannot
+        // ride along with the ADD COLUMN — SQLite refuses to add a UNIQUE column.
+        if (field.isUnique && !field.isId && !dialect.supportsUniqueInlineOnAddColumn) {
+          const indexName = `UQ_${safeName}_${field.name}`;
+          const quoted = dialect.quote(indexName);
+          if ((await db.query(dialect.uniqueConstraintExists(tableName, indexName))).length === 0) {
+            db.log(`Creating unique index ${quoted} on table ${sqlTableName}...`);
+            await db.execute(dialect.createUniqueIndex(quoted, sqlTableName, quoteFields([field.name])));
+            result.uniqueConstraintsAdded += 1;
+          }
+        }
+      }
+      result.tablesAltered += 1;
+    }
+
+    // Unique constraints that are not part of the column definitions above.
+    for (const entry of compoundUniques) {
+      if (await hasUniqueConstraint(db, dialect, tableName, entry.name)) continue;
+      const quoted = dialect.quote(entry.name);
+      if (dialect.supportsNamedUniqueConstraint) {
+        db.log(`Adding compound unique constraint ${quoted} to table ${sqlTableName}...`);
+        await db.execute(dialect.addUniqueConstraint(quoted, sqlTableName, quoteFields(entry.fields)));
+      } else {
+        db.log(`Creating unique index ${quoted} on table ${sqlTableName}...`);
+        await db.execute(dialect.createUniqueIndex(quoted, sqlTableName, quoteFields(entry.fields)));
+        result.indexesCreated += 1;
+        result.uniqueConstraintsAdded += 1;
+      }
+      result.uniqueConstraintsAdded += 1;
+    }
+
+    for (const [idx, directive] of model.indexes.entries()) {
+      const name = directiveName(directive, model.tableName, 'index', idx);
+      if ((await db.query(dialect.indexExists(tableName, name))).length > 0) continue;
+      const quoted = dialect.quote(name);
+      db.log(`Creating index ${quoted} on table ${sqlTableName}...`);
+      await db.execute(dialect.createIndex(quoted, sqlTableName, quoteFields(directive.fields)));
+      result.indexesCreated += 1;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Whether the unique is already there.
+ *
+ * A compound unique created inside `CREATE TABLE` has no separate object to look
+ * for on the providers that keep them, so it is treated as present once the table
+ * exists; the per-column uniques inside a column definition are handled with the
+ * column above.
+ */
+async function hasUniqueConstraint(
+  db: PushDatabase,
+  dialect: PushDialect,
+  tableName: string,
+  name: string,
+): Promise<boolean> {
+  return (await db.query(dialect.uniqueConstraintExists(tableName, name))).length > 0;
+}