@an5/orm 1.0.9 → 1.1.0

package/generator/src/suggest.ts

@@ -0,0 +1,41 @@
+/**
+ * "Did you mean" for typos.
+ *
+ * Lives on its own because two callers need it and neither should own it:
+ * the config loader (a mistyped option key) and the field type registry (a
+ * type written for the wrong database). Both want the nearest candidate out
+ * of a known list, or nothing at all when the input is not close enough that
+ * a suggestion would be honest.
+ */
+
+/** Levenshtein distance between two strings. */
+export function editDistance(a: string, b: string): number {
+  const rows: number[][] = [];
+  for (let i = 0; i <= a.length; i++) rows.push([i, ...new Array<number>(b.length).fill(0)]);
+  for (let j = 0; j <= b.length; j++) rows[0]![j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      rows[i]![j] = Math.min(rows[i - 1]![j]! + 1, rows[i]![j - 1]! + 1, rows[i - 1]![j - 1]! + cost);
+    }
+  }
+  return rows[a.length]![b.length]!;
+}
+
+/**
+ * The candidate closest to `input`, or null when none is close enough to be a
+ * plausible typo. Comparing case-insensitively keeps `nvarchar` from suggesting
+ * something unrelated just because of capitalisation.
+ */
+export function suggest(input: string, candidates: readonly string[]): string | null {
+  let best: string | null = null;
+  let bestDistance = Infinity;
+  for (const candidate of candidates) {
+    const distance = editDistance(input.toLowerCase(), candidate.toLowerCase());
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = candidate;
+    }
+  }
+  return best !== null && bestDistance <= Math.max(2, Math.floor(input.length / 3)) ? best : null;
+}

package/generator/src/type-kinds.ts

@@ -0,0 +1,78 @@
+/**
+ * What a field *is*, for the generators that need a real type.
+ *
+ * The parser gives every generator the same TypeScript type, and that type loses
+ * what a language needs: `INT`, `FLOAT` and `DECIMAL` all arrive as `number`, so
+ * the Go client generated every numeric column as a `string`, and the Python, Rust
+ * and .NET clients turned a `DECIMAL` into an integer type. The declared type is
+ * right there in `Field.sqlType`, so it decides — with the TypeScript type as the
+ * fallback for metadata generated before that was recorded.
+ */
+import { Provider } from './field-types';
+
+/** The categories a generated language type can be built from. */
+export type FieldKind = 'int' | 'bigint' | 'float' | 'bool' | 'date' | 'bytes' | 'json' | 'vector' | 'string';
+
+export interface KindInput {
+  /** The TypeScript type the parser produced, e.g. `number | bigint`. */
+  type: string;
+  /** The type as written in the schema, e.g. `DECIMAL(10,2)`. */
+  sqlType?: string | undefined;
+}
+
+const INT = ['INT', 'INTEGER', 'SMALLINT', 'TINYINT', 'MEDIUMINT', 'INT2', 'INT4', 'SERIAL', 'SMALLSERIAL', 'YEAR'];
+const BIGINT = ['BIGINT', 'INT8', 'BIGSERIAL', 'UNSIGNED BIG INT'];
+const FLOAT = ['FLOAT', 'REAL', 'DOUBLE', 'DOUBLE PRECISION', 'DECIMAL', 'NUMERIC', 'MONEY', 'SMALLMONEY', 'FIXED'];
+const BOOL = ['BIT', 'BOOL', 'BOOLEAN'];
+const DATE = [
+  'DATE', 'DATETIME', 'DATETIME2', 'SMALLDATETIME', 'DATETIMEOFFSET',
+  'TIME', 'TIMETZ', 'TIMESTAMPTZ', 'TIME WITH TIME ZONE', 'TIME WITHOUT TIME ZONE',
+  'TIMESTAMP WITH TIME ZONE', 'TIMESTAMP WITHOUT TIME ZONE',
+];
+const BYTES = ['BINARY', 'VARBINARY', 'IMAGE', 'BLOB', 'TINYBLOB', 'MEDIUMBLOB', 'LONGBLOB', 'BYTEA', 'ROWVERSION', 'BYTES'];
+const JSON = ['JSON', 'JSONB', 'SQL_VARIANT'];
+
+/** `DECIMAL(10,2)` → `DECIMAL`. */
+function declaredBase(sqlType: string): string {
+  const withoutParams = sqlType.replace(/\([^)]*\)/g, ' ').trim();
+  return withoutParams.replace(/\s+/g, ' ').toUpperCase();
+}
+
+/**
+ * The category a field belongs to.
+ *
+ * `TIMESTAMP` is the reason `provider` is a parameter: it is a rowversion on SQL
+ * Server and a point in time everywhere else, and the same word has to produce
+ * bytes in one and a date in the other.
+ */
+export function fieldKind(field: KindInput, provider?: Provider | undefined): FieldKind {
+  const base = field.sqlType ? declaredBase(field.sqlType) : '';
+  if (base) {
+    if (base === 'TIMESTAMP') return provider === 'mssql' ? 'bytes' : 'date';
+    if (INT.includes(base)) return 'int';
+    if (BIGINT.includes(base)) return 'bigint';
+    if (FLOAT.includes(base)) return 'float';
+    if (BOOL.includes(base)) return 'bool';
+    if (DATE.includes(base) || base === 'TIMESTAMP') return 'date';
+    if (BYTES.includes(base)) return 'bytes';
+    if (JSON.includes(base)) return 'json';
+    if (base === 'VECTOR') return 'vector';
+    return 'string';
+  }
+
+  // No declared type: fall back to what the TypeScript type can still tell us. A
+  // plain `number` is an integer here, which is what every generator assumed
+  // before `sqlType` was available.
+  const raw = field.type.trim().toLowerCase();
+  // Checked before the brackets are stripped, or `number[] | string` — the vector
+  // type — would read as a number.
+  if (raw.includes('[]')) return 'vector';
+  const ts = raw.replace(/[?\]]/g, '').trim();
+  if (ts.startsWith('number | bigint')) return 'bigint';
+  if (ts.startsWith('number')) return 'int';
+  if (ts.startsWith('date')) return 'date';
+  if (ts.startsWith('bool')) return 'bool';
+  if (ts.startsWith('buffer')) return 'bytes';
+  if (ts === 'any') return 'json';
+  return 'string';
+}

package/generator/src/types.ts

@@ -1,3 +1,5 @@
+import { Provider } from './field-types';
+
 export interface Field {
   name: string;
   type: string;       // TypeScript type (string, number, boolean, Date, etc.)
@@ -16,14 +18,60 @@ export interface Relation {
   foreignKey: string;
   localKey: string;
   relationName: string;
+  /** From a trailing @description("...") on the relation line. */
+  description?: string;
 }
 
 export interface Model {
   name: string;
   tableName: string;
+  /** Empty for a database with no schemas, or when `@@schema("")` says so. */
   schemaName: string;
+  /**
+   * The database this schema targets. Set by `SchemaParser`, and what decides how a
+   * table name is written — see `bracketedTableName`.
+   */
+  provider?: Provider | undefined;
   fields: Field[];
   relations: Relation[];
   compoundUniques?: string[][];
   description?: string;
 }
+
+/**
+ * The table name as it goes into the generated metadata.
+ *
+ * SQL Server keeps the bracketed form it has always had. Every other provider gets
+ * the bare name, with the schema as a plain prefix, because the brackets are not
+ * portable: `[dbo].[users]` is invalid SQL in PostgreSQL, and on SQLite it fails with
+ * "no such table: dbo.users" — which is why the adapters had to strip it afterwards.
+ * A bare name is correct everywhere once the adapter quotes it, and the adapters
+ * already quote per dialect (`quote()` in `@an5/adapters`, `An5DbContext.Quote()` in
+ * the .NET client), so the one form that needs no translation is the one emitted.
+ *
+ * `dbo` is SQL Server's default schema and only SQL Server's: with `@@schema("")` —
+ * an empty schema, meant for databases that have no schema concept — the prefix has
+ * to go, because `[].[users]` is not valid SQL. The `[${schemaName}].[${tableName}]`
+ * formula used to be written out in six places, so every dialect got `[dbo]`.
+ */
+export function bracketedTableName(model: Model): string {
+  const qualified = model.schemaName
+    ? `${model.schemaName}.${model.tableName}`
+    : model.tableName;
+  if ((model.provider ?? 'mssql') !== 'mssql') return qualified;
+  return model.schemaName
+    ? `[${model.schemaName}].[${model.tableName}]`
+    : `[${model.tableName}]`;
+}
+
+/**
+ * The table name as `schema.table`, for clients that pass a string instead of SQL.
+ *
+ * Unquoted for the same reason as `bracketedTableName`: these strings go to the same
+ * per-dialect quoting.
+ */
+export function dottedTableName(model: Model): string {
+  return model.schemaName
+    ? `${model.schemaName}.${model.tableName}`
+    : model.tableName;
+}

package/package.json

@@ -1,10 +1,22 @@
 {
   "name": "@an5/orm",
-  "version": "1.0.9",
-  "description": "The lightweight ORM for SQL Server with support for TypeScript, Python, .NET (C#), and Go.",
+  "version": "1.1.0",
+  "description": "The lightweight ORM for SQL Server with support for TypeScript, Python, .NET (C#), Go, and Rust.",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./generator": {
+      "types": "./dist/generator/src/api.d.ts",
+      "default": "./dist/generator/src/api.js"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist/**/*.{js,d.ts}",
     "generator/src/**/*.ts",
@@ -17,9 +29,11 @@
     "url": "https://github.com/an5ORM/an5Orm.git"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && tsc -p generator/tsconfig.json && node scripts/normalize-eol.js",
+    "typecheck:cli": "tsc -p tsconfig.cli.json",
     "pretest": "npm run build",
-    "prepack": "npm run build",
+    "prepack": "npm run build && npm run verify:pack",
+    "prepublishOnly": "npm run verify:pack",
     "generate": "npx tsx generator/src/index.ts",
     "db:push": "npx tsx push.ts",
     "db:pull": "npx tsx pull.ts",
@@ -33,10 +47,16 @@
     "db:migrate:status": "npx tsx migrate.ts status",
     "release:cli": "npx tsx scripts/release-cli.ts",
     "release": "node scripts/release.js",
-    "test": "node test/smoke.test.js && node test/unit.test.js",
+    "test": "npm run typecheck:cli && node test/smoke.test.js && node test/unit.test.js && node test/generator-regressions.test.js && node --test test/config.test.js && node --test test/provider-types.test.js && node --test test/provider-push.test.js && node --test test/provider-push.sqlite.test.js && node --test test/type-kinds.test.js && node --test test/declarations.test.js && node --test test/version-sync.test.js",
     "test:unit": "node test/unit.test.js",
     "test:generator": "npm run generate && node test/generator.test.js",
-    "test:integration:live": "node test/live-db.integration.test.js"
+    "test:generator:regressions": "node test/generator-regressions.test.js",
+    "test:provider-types": "node --test test/provider-types.test.js",
+    "test:provider-push": "node --test test/provider-push.test.js",
+    "test:provider-push:sqlite": "node --test test/provider-push.sqlite.test.js",
+    "test:integration:live": "node test/live-db.integration.test.js",
+    "verify:pack": "node scripts/verify-pack.js",
+    "normalize:eol": "node scripts/normalize-eol.js"
   },
   "dependencies": {
     "@an5/adapters": "^0.2.6",