@an5/orm 1.3.2 → 1.3.4

package/dist/generator/src/attributes.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * Reading `@attribute(...)` arguments from a `.an5` field or model line.
+ *
+ * The schema used to be read with regexes such as `/@default\((.*)\)/`, which
+ * ran to the *last* `)` on the line. A field with `@default(now())` followed by
+ * `@description("...")` therefore had `now()) @description("..."` as its default
+ * expression, and `db:push` emitted SQL no database accepts. The closing
+ * parenthesis has to be the one that matches the opening one — parentheses nest
+ * (`now()`, `uuid()`, `lower(...)`) and quoted strings may contain both.
+ *
+ * These helpers only read attributes; they do not validate the schema language.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAttribute = hasAttribute;
+exports.attributeArgs = attributeArgs;
+exports.unquote = unquote;
+exports.splitSchemaLines = splitSchemaLines;
+exports.stringOption = stringOption;
+exports.fieldListOption = fieldListOption;
+exports.parseIndexDirective = parseIndexDirective;
+/** Finds a matching `)` for the `(` at `open`, ignoring parentheses inside quotes. */
+function closingParenthesis(line, open) {
+    let depth = 0;
+    let quote = null;
+    for (let index = open; index < line.length; index += 1) {
+        const character = line[index];
+        if (quote !== null) {
+            if (character === '\\') {
+                index += 1;
+                continue;
+            }
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        // A triple-quoted string may span lines and may contain either quote, so it
+        // has to be skipped as a unit before the single-quote rule below sees it.
+        if (character === '"' && line[index + 1] === '"' && line[index + 2] === '"') {
+            const end = line.indexOf('"""', index + 3);
+            if (end < 0)
+                return -1;
+            index = end + 2;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === '(') {
+            depth += 1;
+            continue;
+        }
+        if (character === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+/** Whether `line` has the attribute, with or without arguments. */
+function hasAttribute(line, name) {
+    const pattern = new RegExp(`(^|\\s)${escapeRegExp(name)}(?![\\w])`);
+    return pattern.test(line);
+}
+/**
+ * The raw argument text of the first `name(...)` on `line`.
+ *
+ * Returns `undefined` when the attribute is absent, or when it is written
+ * without parentheses. The returned text keeps its quotes, so callers decide
+ * whether they are reading a string, a number or an expression.
+ */
+function attributeArgs(line, name) {
+    const pattern = new RegExp(`(^|\\s)${escapeRegExp(name)}\\s*\\(`, 'g');
+    const match = pattern.exec(line);
+    if (!match)
+        return undefined;
+    const open = line.indexOf('(', match.index + match[0].length - 1);
+    if (open < 0)
+        return undefined;
+    const close = closingParenthesis(line, open);
+    if (close < 0)
+        return undefined;
+    return line.slice(open + 1, close);
+}
+/** Strips one pair of surrounding double quotes, if present. */
+function unquote(value) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    // Triple quotes allow a view's SQL to be written over several lines without
+    // escaping: `@@sql("""
+    //   SELECT ...
+    // """)`. The common indentation is removed so the generated DDL is not
+    // needlessly indented, while meaningful inner indentation is kept.
+    //
+    // The closing `"""` ends the string, not the argument list: `)` may follow on
+    // the same line or the next one, so the body is found by searching for the
+    // closing quotes rather than assuming they sit at the very end.
+    if (trimmed.startsWith('"""')) {
+        const end = trimmed.indexOf('"""', 3);
+        if (end >= 0) {
+            const body = trimmed.slice(3, end).replace(/^\r?\n/, '').replace(/\r?\n$/, '');
+            const lines = body.split(/\r?\n/);
+            const indents = lines
+                .filter((line) => line.trim() !== '')
+                .map((line) => line.match(/^[ \t]*/)?.[0].length ?? 0);
+            const dedent = indents.length > 0 ? Math.min(...indents) : 0;
+            return lines.map((line) => line.slice(dedent)).join('\n');
+        }
+    }
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+/**
+ * Whether `line` holds a complete `@@sql("""…""")` directive.
+ *
+ * The closing `"""` and the `)` that closes the attribute need not share a line,
+ * so this asks whether the argument list is balanced *and* the body it contains
+ * has been closed. An incomplete directive is kept as a pending line instead of
+ * being handed to the parser as if the SQL ended at the newline.
+ */
+function isCompleteViewDirective(line) {
+    const args = attributeArgs(line, '@@sql') ?? attributeArgs(line, '@@definition');
+    if (args === undefined)
+        return false;
+    const trimmed = args.trim();
+    if (!trimmed.startsWith('"""'))
+        return false;
+    return trimmed.slice(3).includes('"""');
+}
+/**
+ * Splits schema text into logical lines, keeping a triple-quoted `@@sql` body on
+ * one line.
+ *
+ * The parsers read a schema line by line. Without this, a multi-line view body
+ * would end the directive at its first newline and the rest of the `SELECT`
+ * would be read as fields of the view. Newlines inside the quotes are preserved;
+ * only the split points change.
+ */
+function splitSchemaLines(text) {
+    const lines = [];
+    let pending = null;
+    for (const rawLine of text.split(/\r?\n/)) {
+        if (pending !== null) {
+            pending += `\n${rawLine}`;
+            if (isCompleteViewDirective(pending)) {
+                lines.push(pending);
+                pending = null;
+            }
+            continue;
+        }
+        const start = /@@(?:sql|definition)\s*\(\s*"""/.exec(rawLine);
+        if (start) {
+            if (isCompleteViewDirective(rawLine)) {
+                lines.push(rawLine);
+                continue;
+            }
+            pending = rawLine;
+            continue;
+        }
+        lines.push(rawLine);
+    }
+    if (pending !== null)
+        lines.push(pending);
+    return lines;
+}
+/**
+ * Reads a named string option from an attribute argument list, e.g.
+ * `map: "UQ_users_email"` in `@unique(map: "UQ_users_email")`.
+ */
+function stringOption(args, key) {
+    if (!args)
+        return undefined;
+    const pattern = new RegExp(`\\b${escapeRegExp(key)}\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`);
+    return pattern.exec(args)?.[1];
+}
+/** Reads a named field-list option, e.g. `include: [email, tenantId]`. */
+function fieldListOption(args, key) {
+    if (!args)
+        return undefined;
+    const pattern = new RegExp(`\\b${escapeRegExp(key)}\\s*:\\s*\\[([^\\]]*)\\]`);
+    const value = pattern.exec(args)?.[1];
+    if (value === undefined)
+        return undefined;
+    return value.split(',').map((field) => field.trim()).filter(Boolean);
+}
+/**
+ * Parses the inside of `@@unique([a, b], map: "…", include: […], …)`.
+ *
+ * The directive is the one place a schema can carry raw SQL (`filter`,
+ * `options`), so its argument list is balanced rather than cut at the first
+ * `)`. A filter such as `(deletedAt IS NULL)` used to truncate the directive.
+ */
+function parseIndexDirective(args) {
+    if (!args)
+        return null;
+    const fieldsMatch = args.match(/^\s*\[([\w\s,]*)\]/);
+    if (!fieldsMatch)
+        return null;
+    const fields = (fieldsMatch[1] ?? '').split(',').map((field) => field.trim()).filter(Boolean);
+    if (fields.length === 0)
+        return null;
+    const rest = args.slice(fieldsMatch[0].length);
+    const directive = { fields };
+    const name = stringOption(rest, 'map');
+    if (name)
+        directive.name = name;
+    const includeFields = fieldListOption(rest, 'include');
+    if (includeFields && includeFields.length > 0)
+        directive.includeFields = includeFields;
+    const filter = stringOption(rest, 'filter');
+    if (filter !== undefined)
+        directive.filter = filter;
+    const options = stringOption(rest, 'options');
+    if (options !== undefined)
+        directive.options = options;
+    return directive;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/generator/src/code-generator.js

@@ -62,11 +62,27 @@ export interface TableClient<T, WhereInput = any, _Select = any, Include = any,
   groupBy(args: GroupByArgs): Promise<any[]>;
   upsert(args: UpsertArgs): Promise<T>;
 }
+
+/**
+ * A read-only client for a view block.
+ *
+ * The same query surface as TableClient without any write method, matching the
+ * runtime ViewClient in @an5/adapters.
+ */
+export interface ViewClient<T, WhereInput = any, _Select = any, Include = any, FindManyArgs = any, FindFirstArgs = any, FindUniqueArgs = any, AggregateArgs = any, GroupByArgs = any> {
+  findMany(args?: FindManyArgs): Promise<T[]>;
+  vectorSearch(args: { vector: number[]; take?: number; where?: WhereInput; include?: Include; vectorField?: string; distanceMetric?: 'cosine' | 'euclidean' | 'dot'; }): Promise<(T & { distance: number })[]>;
+  findFirst(args?: FindFirstArgs): Promise<T | null>;
+  findUnique(args?: FindUniqueArgs): Promise<T | null>;
+  count(args?: { where?: WhereInput; }): Promise<number>;
+  aggregate(args: AggregateArgs): Promise<any>;
+  groupBy(args: GroupByArgs): Promise<any[]>;
+}
 `;
         fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'base.ts'), baseTs);
     }
     generateModelFile(model) {
-        let content = `import { An5, TableClient } from './base';\n`;
+        let content = `import { An5, ${model.isView ? 'ViewClient' : 'TableClient'} } from './base';\n`;
         const relModels = [...new Set(model.relations.map(r => r.type))];
         for (const relModel of relModels) {
             if (relModel !== model.name) {
@@ -118,23 +134,32 @@ export interface TableClient<T, WhereInput = any, _Select = any, Include = any,
             includeRels.push(`_count?: boolean | { select?: { ${model.relations.map(r => `${r.name}?: boolean`).join('; ')} } }`);
         }
         content += `export type ${model.name}Include = { ${includeRels.join('; ')}${includeRels.length > 0 ? ';' : ''} };\n`;
-        content += `export type ${model.name}CreateInput = { ${model.fields.map(f => `${f.name}${f.isOptional || f.hasDefault ? '?' : ''}: ${this.inputType(f.type)}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; }`).join('; ')} };\n`;
-        content += `export type ${model.name}UpdateInput = { ${model.fields.filter(f => !f.isId).map(f => `${f.name}?: ${f.type === 'number' ? 'number | An5.IntFieldUpdateOperationsInput' : this.inputType(f.type)}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; set?: ${r.type}WhereInput | ${r.type}WhereInput[]; disconnect?: ${r.type}WhereInput | ${r.type}WhereInput[]; delete?: ${r.type}WhereInput | ${r.type}WhereInput[]; update?: { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; }[]; upsert?: { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; }[]; }`).join('; ')} };\n`;
+        if (!model.isView) {
+            content += `export type ${model.name}CreateInput = { ${model.fields.map(f => `${f.name}${f.isOptional || f.hasDefault ? '?' : ''}: ${this.inputType(f.type)}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; }`).join('; ')} };\n`;
+            content += `export type ${model.name}UpdateInput = { ${model.fields.filter(f => !f.isId).map(f => `${f.name}?: ${f.type === 'number' ? 'number | An5.IntFieldUpdateOperationsInput' : this.inputType(f.type)}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; set?: ${r.type}WhereInput | ${r.type}WhereInput[]; disconnect?: ${r.type}WhereInput | ${r.type}WhereInput[]; delete?: ${r.type}WhereInput | ${r.type}WhereInput[]; update?: { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; }[]; upsert?: { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; }[]; }`).join('; ')} };\n`;
+        }
         content += `export type ${model.name}OrderByInput = { ${model.fields.map(f => `${f.name}?: An5.SortOrder`).join('; ')} };\n`;
         content += `export type ${model.name}FindManyArgs = { where?: ${model.name}WhereInput; orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[]; take?: number; skip?: number; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
         content += `export type ${model.name}FindFirstArgs = { where?: ${model.name}WhereInput; orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[]; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
         content += `export type ${model.name}FindUniqueArgs = { where?: ${model.name}WhereInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
-        content += `export type ${model.name}CreateArgs = { data: ${model.name}CreateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
-        content += `export type ${model.name}UpdateArgs = { where: ${model.name}WhereInput; data: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
-        content += `export type ${model.name}UpsertArgs = { where: ${model.name}WhereInput; create: ${model.name}CreateInput; update: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
-        content += `export type ${model.name}DeleteArgs = { where: ${model.name}WhereInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        if (!model.isView) {
+            content += `export type ${model.name}CreateArgs = { data: ${model.name}CreateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+            content += `export type ${model.name}UpdateArgs = { where: ${model.name}WhereInput; data: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+            content += `export type ${model.name}UpsertArgs = { where: ${model.name}WhereInput; create: ${model.name}CreateInput; update: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+            content += `export type ${model.name}DeleteArgs = { where: ${model.name}WhereInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        }
         content += `export type ${model.name}ScalarFieldEnum = ${model.fields.map(f => `'${f.name}'`).join(' | ') || 'never'};\n`;
         content += `export type ${model.name}AggregateArgs = { where?: ${model.name}WhereInput; _count?: true | { _all?: true; ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _sum?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _avg?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _min?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _max?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; };\n`;
         const numericHavingFields = model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: An5.NumberFilter | number`).join('; ');
         const scalarHavingFields = model.fields.map(f => `${f.name}?: any`).join('; ');
         content += `export type ${model.name}AggregateHavingInput = { _count?: { _all?: An5.NumberFilter | number; ${model.fields.map(f => `${f.name}?: An5.NumberFilter | number`).join('; ')} }; _sum?: { ${numericHavingFields} }; _avg?: { ${numericHavingFields} }; _min?: { ${scalarHavingFields} }; _max?: { ${scalarHavingFields} }; };\n`;
         content += `export type ${model.name}GroupByArgs = { by: ${model.name}ScalarFieldEnum | ${model.name}ScalarFieldEnum[]; where?: ${model.name}WhereInput; having?: ${model.name}AggregateHavingInput; orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[]; skip?: number; take?: number; _count?: true | { _all?: true; ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _sum?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _avg?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _min?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _max?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; };\n`;
-        content += `export type ${model.name}TableClient = TableClient<\n  ${model.name},\n  ${model.name}WhereInput,\n  ${model.name}Select,\n  ${model.name}Include,\n  ${model.name}CreateInput,\n  ${model.name}UpdateInput,\n  ${model.name}FindManyArgs,\n  ${model.name}FindFirstArgs,\n  ${model.name}FindUniqueArgs,\n  ${model.name}CreateArgs,\n  ${model.name}UpdateArgs,\n  ${model.name}UpsertArgs,\n  ${model.name}DeleteArgs,\n  ${model.name}AggregateArgs,\n  ${model.name}GroupByArgs\n>;\n`;
+        if (model.isView) {
+            content += `export type ${model.name}ViewClient = ViewClient<\n  ${model.name},\n  ${model.name}WhereInput,\n  ${model.name}Select,\n  ${model.name}Include,\n  ${model.name}FindManyArgs,\n  ${model.name}FindFirstArgs,\n  ${model.name}FindUniqueArgs,\n  ${model.name}AggregateArgs,\n  ${model.name}GroupByArgs\n>;\n`;
+        }
+        else {
+            content += `export type ${model.name}TableClient = TableClient<\n  ${model.name},\n  ${model.name}WhereInput,\n  ${model.name}Select,\n  ${model.name}Include,\n  ${model.name}CreateInput,\n  ${model.name}UpdateInput,\n  ${model.name}FindManyArgs,\n  ${model.name}FindFirstArgs,\n  ${model.name}FindUniqueArgs,\n  ${model.name}CreateArgs,\n  ${model.name}UpdateArgs,\n  ${model.name}UpsertArgs,\n  ${model.name}DeleteArgs,\n  ${model.name}AggregateArgs,\n  ${model.name}GroupByArgs\n>;\n`;
+        }
         fs_1.default.writeFileSync(path_1.default.join(this.outputDir, `${model.name}.ts`), content);
     }
     generateIndexTs(models) {
@@ -164,17 +189,24 @@ export interface TableClient<T, WhereInput = any, _Select = any, Include = any,
             content += `  export type ${model.name}WhereInput = ${model.name}Types.${model.name}WhereInput;\n`;
             content += `  export type ${model.name}Select = ${model.name}Types.${model.name}Select;\n`;
             content += `  export type ${model.name}Include = ${model.name}Types.${model.name}Include;\n`;
-            content += `  export type ${model.name}CreateInput = ${model.name}Types.${model.name}CreateInput;\n`;
-            content += `  export type ${model.name}UpdateInput = ${model.name}Types.${model.name}UpdateInput;\n`;
+            if (!model.isView) {
+                content += `  export type ${model.name}CreateInput = ${model.name}Types.${model.name}CreateInput;\n`;
+                content += `  export type ${model.name}UpdateInput = ${model.name}Types.${model.name}UpdateInput;\n`;
+            }
             content += `  export type ${model.name}OrderByInput = ${model.name}Types.${model.name}OrderByInput;\n`;
             content += `  export type ${model.name}FindManyArgs = ${model.name}Types.${model.name}FindManyArgs;\n`;
             content += `  export type ${model.name}FindFirstArgs = ${model.name}Types.${model.name}FindFirstArgs;\n`;
             content += `  export type ${model.name}FindUniqueArgs = ${model.name}Types.${model.name}FindUniqueArgs;\n`;
-            content += `  export type ${model.name}CreateArgs = ${model.name}Types.${model.name}CreateArgs;\n`;
-            content += `  export type ${model.name}UpdateArgs = ${model.name}Types.${model.name}UpdateArgs;\n`;
-            content += `  export type ${model.name}UpsertArgs = ${model.name}Types.${model.name}UpsertArgs;\n`;
-            content += `  export type ${model.name}DeleteArgs = ${model.name}Types.${model.name}DeleteArgs;\n`;
-            content += `  export type ${model.name}TableClient = ${model.name}Types.${model.name}TableClient;\n`;
+            if (!model.isView) {
+                content += `  export type ${model.name}CreateArgs = ${model.name}Types.${model.name}CreateArgs;\n`;
+                content += `  export type ${model.name}UpdateArgs = ${model.name}Types.${model.name}UpdateArgs;\n`;
+                content += `  export type ${model.name}UpsertArgs = ${model.name}Types.${model.name}UpsertArgs;\n`;
+                content += `  export type ${model.name}DeleteArgs = ${model.name}Types.${model.name}DeleteArgs;\n`;
+                content += `  export type ${model.name}TableClient = ${model.name}Types.${model.name}TableClient;\n`;
+            }
+            else {
+                content += `  export type ${model.name}ViewClient = ${model.name}Types.${model.name}ViewClient;\n`;
+            }
             content += `  export type ${model.name}ScalarFieldEnum = ${model.name}Types.${model.name}ScalarFieldEnum;\n`;
             content += `  export type ${model.name}AggregateArgs = ${model.name}Types.${model.name}AggregateArgs;\n`;
             content += `  export type ${model.name}GroupByArgs = ${model.name}Types.${model.name}GroupByArgs;\n`;
@@ -184,9 +216,10 @@ export interface TableClient<T, WhereInput = any, _Select = any, Include = any,
         const addedProps = new Set();
         for (const model of models) {
             const props = this.getAllPropertyVariations(model.name);
+            const clientType = `${model.name}Types.${model.name}${model.isView ? 'ViewClient' : 'TableClient'}`;
             for (const prop of props) {
                 if (!addedProps.has(prop)) {
-                    content += `  ${prop}!: ${model.name}Types.${model.name}TableClient;\n`;
+                    content += `  ${prop}!: ${clientType};\n`;
                     addedProps.add(prop);
                 }
             }

package/dist/generator/src/config.d.ts

@@ -125,8 +125,8 @@ export declare function resolveConnectionString(config: An5OrmConfig, env?: EnvL
  *
  * Falls back to SQL Server when the scheme is unknown — it is the default
  * provider, and ADO-style strings (`Server=...;Database=...`) have no scheme to
- * read. `sqlite://`, a bare path ending in `.sqlite`, `.sqlite3` or `.db` — the same
- * list `An5Adapter` uses.
+ * read. `:memory:`, any `sqlite:` URI (`sqlite://`, `sqlite::memory:`) and a bare
+ * path ending in `.sqlite`, `.sqlite3` or `.db` — the same list `An5Adapter` uses.
  */
 export declare function detectProvider(connectionString: string | undefined | null): Provider;
 /**

package/dist/generator/src/config.js

@@ -270,8 +270,8 @@ function resolveConnectionString(config, env = process.env, command = 'this comm
  *
  * Falls back to SQL Server when the scheme is unknown — it is the default
  * provider, and ADO-style strings (`Server=...;Database=...`) have no scheme to
- * read. `sqlite://`, a bare path ending in `.sqlite`, `.sqlite3` or `.db` — the same
- * list `An5Adapter` uses.
+ * read. `:memory:`, any `sqlite:` URI (`sqlite://`, `sqlite::memory:`) and a bare
+ * path ending in `.sqlite`, `.sqlite3` or `.db` — the same list `An5Adapter` uses.
  */
 function detectProvider(connectionString) {
     // Lower-cased: a URI scheme is case-insensitive, so `MySQL://` is the same
@@ -287,8 +287,9 @@ function detectProvider(connectionString) {
         return 'postgres';
     if (cs.startsWith('mysql://') || cs.startsWith('mariadb://'))
         return 'mysql';
-    if (SQLITE_FILE_SUFFIXES.some((suffix) => cs.endsWith(suffix)))
+    if (cs === ':memory:' || cs.startsWith('sqlite:') || SQLITE_FILE_SUFFIXES.some((suffix) => cs.endsWith(suffix))) {
         return 'sqlite';
+    }
     return field_types_1.DEFAULT_PROVIDER;
 }
 /** File extensions that mean SQLite when there is no scheme to read. */

package/dist/generator/src/dialect.d.ts

@@ -32,9 +32,23 @@ export interface ColumnSpec {
     isId: boolean;
     isUnique: boolean;
     isOptional: boolean;
+    /** `@unique(map: "…")`: the constraint name both push and migrate must use. */
+    uniqueName?: string | undefined;
     /** The raw `@default(...)` expression, e.g. `now()` or `"draft"`. */
     defaultExpr?: string | undefined;
 }
+/**
+ * The extra clauses `@@index(..., include:, filter:, options:)` asks for.
+ *
+ * Field names are already quoted by the caller. `options` is SQL Server syntax
+ * (`WITH (FILLFACTOR = 90, ONLINE = ON)`); other providers either support the
+ * standard subset (`include`, `filter`) or ignore what they cannot express.
+ */
+export interface IndexOptions {
+    includeFields?: string[] | undefined;
+    filter?: string | undefined;
+    options?: string | undefined;
+}
 export interface PushDialect {
     readonly provider: Provider;
     /** Whether this database can be written to with DDL at all. */
@@ -61,6 +75,16 @@ export interface PushDialect {
     readonly supportsUniqueInlineOnAddColumn: boolean;
     /** Query returning one row when the table exists. */
     tableExists(raw: string): string;
+    /** Query returning one row when a view exists. */
+    viewExists(raw: string): string;
+    /**
+     * Query returning the stored view definition in a single `definition` column.
+     *
+     * Used to skip a push that would recreate an unchanged view. The value may be
+     * the body alone (PostgreSQL/MySQL) or the full `CREATE VIEW` text (SQL
+     * Server/SQLite); `normalizeViewSql` compares either form.
+     */
+    viewDefinition(raw: string): string;
     /** Query returning one row when the column exists. */
     columnExists(raw: string, column: string): string;
     /** Query returning one row when the unique constraint exists. */
@@ -70,12 +94,39 @@ export interface PushDialect {
     /** One column definition, as it appears inside `CREATE TABLE`. */
     columnDefinition(column: ColumnSpec): string;
     createTable(quotedTable: string, columnDefs: string[]): string;
-    createIndex(quotedName: string, quotedTable: string, quotedFields: string[]): string;
+    /**
+     * Whether `CREATE OR REPLACE VIEW` (or `CREATE OR ALTER VIEW`) is available.
+     *
+     * SQLite has neither, so a changed view needs `DROP VIEW` first; see `dropView`.
+     */
+    readonly supportsCreateOrReplaceView: boolean;
+    /** `CREATE [OR REPLACE|OR ALTER] VIEW ... AS <select>`. */
+    createView(quotedView: string, selectSql: string): string;
+    /** `DROP VIEW IF EXISTS`, for providers without create-or-replace. */
+    dropView(quotedView: string): string;
+    createIndex(quotedName: string, quotedTable: string, quotedFields: string[], options?: IndexOptions): string;
     createUniqueIndex(quotedName: string, quotedTable: string, quotedFields: string[]): string;
     /** `ALTER TABLE ... ADD <column>`, nullability included. */
     addColumn(quotedTable: string, column: ColumnSpec): string;
     addUniqueConstraint(quotedName: string, quotedTable: string, quotedFields: string[]): string;
 }
+/**
+ * The `SELECT` body of a view definition.
+ *
+ * Catalogs return a full `CREATE VIEW ... AS ...` statement or the bare body,
+ * depending on the provider (and on whether `OBJECT_DEFINITION` is available).
+ * `@@sql` wants the body alone, so both forms reduce to the same text.
+ */
+export declare function viewSqlBody(sql: string | null | undefined): string;
+/**
+ * Normalizes a view definition for comparison.
+ *
+ * A catalog may return `CREATE VIEW [x] AS SELECT ...` while the schema holds
+ * only `SELECT ...`. Whitespace and case are not meaningful here either, so both
+ * forms reduce to the same string; comparing the raw text would make every push
+ * think the view changed.
+ */
+export declare function normalizeViewSql(sql: string | null | undefined): string;
 /** The dialect that writes DDL for a provider. */
 export declare function dialectFor(provider: Provider): PushDialect;
 /**

package/dist/generator/src/dialect.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sqlLiteral = sqlLiteral;
+exports.viewSqlBody = viewSqlBody;
+exports.normalizeViewSql = normalizeViewSql;
 exports.dialectFor = dialectFor;
 exports.defaultClause = defaultClause;
 /** `schema.table` reduced to the bare object name, e.g. `dbo.widgets`. */
@@ -78,6 +80,78 @@ function buildTableExists(provider) {
         }
     };
 }
+/**
+ * Where a view's existence and definition are recorded.
+ *
+ * SQL Server keeps both in `sys.views`/`OBJECT_DEFINITION`; PostgreSQL and MySQL
+ * expose the body through their catalogs; SQLite stores the original statement in
+ * `sqlite_master`. The returned definition is compared with `normalizeViewSql`,
+ * which accepts either a full `CREATE VIEW` statement or a bare `SELECT`.
+ */
+function buildViewExists(provider) {
+    return (raw) => {
+        const { schema, name } = splitQualified(raw);
+        switch (provider) {
+            case 'mssql':
+                return `SELECT name FROM sys.views WHERE object_id = OBJECT_ID(${sqlLiteral(objectName(raw))})`;
+            case 'postgres':
+                return `SELECT viewname FROM pg_views WHERE schemaname = ${schema ? sqlLiteral(schema) : defaultSchema(provider, undefined)} AND viewname = ${sqlLiteral(name)}`;
+            case 'mysql':
+                return (`SELECT table_name FROM information_schema.views WHERE table_schema = ${schema ? sqlLiteral(schema) : 'DATABASE()'} ` +
+                    `AND table_name = ${sqlLiteral(name)}`);
+            case 'sqlite':
+                return `SELECT name FROM sqlite_master WHERE type = 'view' AND name = ${sqlLiteral(name)}`;
+            default:
+                return '';
+        }
+    };
+}
+function buildViewDefinition(provider) {
+    return (raw) => {
+        const { schema, name } = splitQualified(raw);
+        switch (provider) {
+            case 'mssql':
+                return `SELECT OBJECT_DEFINITION(OBJECT_ID(${sqlLiteral(objectName(raw))})) AS definition FROM sys.views WHERE object_id = OBJECT_ID(${sqlLiteral(objectName(raw))})`;
+            case 'postgres':
+                return (`SELECT definition FROM pg_views WHERE schemaname = ${schema ? sqlLiteral(schema) : defaultSchema(provider, undefined)} ` +
+                    `AND viewname = ${sqlLiteral(name)}`);
+            case 'mysql':
+                return (`SELECT view_definition AS definition FROM information_schema.views WHERE table_schema = ` +
+                    `${schema ? sqlLiteral(schema) : 'DATABASE()'} AND table_name = ${sqlLiteral(name)}`);
+            case 'sqlite':
+                return `SELECT sql AS definition FROM sqlite_master WHERE type = 'view' AND name = ${sqlLiteral(name)}`;
+            default:
+                return '';
+        }
+    };
+}
+/**
+ * The `SELECT` body of a view definition.
+ *
+ * Catalogs return a full `CREATE VIEW ... AS ...` statement or the bare body,
+ * depending on the provider (and on whether `OBJECT_DEFINITION` is available).
+ * `@@sql` wants the body alone, so both forms reduce to the same text.
+ */
+function viewSqlBody(sql) {
+    if (!sql)
+        return '';
+    let body = sql.trim();
+    const create = body.match(/^\s*CREATE\s+(?:OR\s+(?:ALTER|REPLACE)\s+)?VIEW\b[\s\S]*?\sAS\b\s*([\s\S]*)$/i);
+    if (create?.[1] !== undefined)
+        body = create[1];
+    return body.replace(/;\s*$/, '').trim();
+}
+/**
+ * Normalizes a view definition for comparison.
+ *
+ * A catalog may return `CREATE VIEW [x] AS SELECT ...` while the schema holds
+ * only `SELECT ...`. Whitespace and case are not meaningful here either, so both
+ * forms reduce to the same string; comparing the raw text would make every push
+ * think the view changed.
+ */
+function normalizeViewSql(sql) {
+    return viewSqlBody(sql).replace(/\s+/g, ' ').trim().toLowerCase();
+}
 function buildColumnExists(provider) {
     return (raw, column) => {
         const { schema, name } = splitQualified(raw);
@@ -186,6 +260,38 @@ function identityKeyword(column, provider) {
             return '';
     }
 }
+/**
+ * Renders `CREATE [UNIQUE] INDEX`, carrying the `@@index` options where the
+ * provider understands them.
+ *
+ * SQL Server writes `INCLUDE (...) WHERE <filter> WITH (<options>)`; PostgreSQL
+ * shares the standard `INCLUDE`/`WHERE` subset; SQLite has partial indexes but no
+ * covering indexes; MySQL has neither, so the base index is the whole statement.
+ * Dropping an unsupported clause keeps the index valid — it only means the engine
+ * cannot use it for a narrower scan.
+ */
+function createIndexSql(kind, quotedName, quotedTable, quotedFields, options, provider) {
+    const statement = kind === 'INDEX' ? 'CREATE INDEX' : 'CREATE UNIQUE INDEX';
+    const base = `${statement} ${quotedName} ON ${quotedTable} (${quotedFields.join(', ')})`;
+    if (!options)
+        return base;
+    const include = options.includeFields && options.includeFields.length > 0
+        ? ` INCLUDE (${options.includeFields.join(', ')})`
+        : '';
+    const filter = options.filter ? ` WHERE ${options.filter}` : '';
+    const withClause = options.options ? ` WITH (${options.options})` : '';
+    switch (provider) {
+        case 'mssql':
+            return `${base}${include}${filter}${withClause}`;
+        case 'postgres':
+            return `${base}${include}${filter}`;
+        case 'sqlite':
+            return `${base}${filter}`;
+        default:
+            // MySQL alone: no INCLUDE, no partial indexes and no WITH options.
+            return base;
+    }
+}
 function createDialect(provider, quote) {
     const supportsUniqueInlineOnAddColumn = provider !== 'sqlite';
     const quoteTable = (raw) => {
@@ -207,7 +313,14 @@ function createDialect(provider, quote) {
             ? `${quote(column.name)} ${sqlType} ${identity}`
             : `${quote(column.name)} ${sqlType}`;
         const nullable = column.isOptional ? '' : ' NOT NULL';
-        const unique = column.isUnique && !column.isId ? ' UNIQUE' : '';
+        // Without `map:` the database names the constraint; with it, push has to use
+        // the schema's name so the next migration recognises the artifact instead of
+        // trying to add a second unique for the same column.
+        const unique = column.isUnique && !column.isId
+            ? column.uniqueName
+                ? ` CONSTRAINT ${quote(column.uniqueName)} UNIQUE`
+                : ' UNIQUE'
+            : '';
         const defaultSql = defaultClause(column.defaultExpr, provider);
         const defaultPart = defaultSql ? ` ${defaultSql}` : '';
         if (column.isId) {
@@ -223,14 +336,29 @@ function createDialect(provider, quote) {
         quoteTable,
         supportsNamedUniqueConstraint: provider !== 'sqlite',
         supportsUniqueInlineOnAddColumn,
+        supportsCreateOrReplaceView: provider !== 'sqlite',
         tableExists: buildTableExists(provider),
+        viewExists: buildViewExists(provider),
+        viewDefinition: buildViewDefinition(provider),
         columnExists: buildColumnExists(provider),
         uniqueConstraintExists: buildUniqueConstraintExists(provider),
         indexExists: buildIndexExists(provider),
         columnDefinition,
         createTable: (table, columnDefs) => `CREATE TABLE ${table} (\n  ${columnDefs.join(',\n  ')}\n)`,
-        createIndex: (name, table, fields) => `CREATE INDEX ${name} ON ${table} (${list(fields)})`,
-        createUniqueIndex: (name, table, fields) => `CREATE UNIQUE INDEX ${name} ON ${table} (${list(fields)})`,
+        createView: (view, selectSql) => {
+            // `@@sql` is the SELECT body, but a definition pasted from a catalog may
+            // still carry its `CREATE VIEW ... AS` header; dropping it here means such a
+            // schema produces one statement instead of `CREATE VIEW ... AS CREATE VIEW`.
+            const body = viewSqlBody(selectSql).trim();
+            if (provider === 'mssql')
+                return `CREATE OR ALTER VIEW ${view} AS\n${body}`;
+            if (provider === 'sqlite')
+                return `CREATE VIEW ${view} AS\n${body}`;
+            return `CREATE OR REPLACE VIEW ${view} AS\n${body}`;
+        },
+        dropView: (view) => `DROP VIEW IF EXISTS ${view}`,
+        createIndex: (name, table, fields, options) => createIndexSql('INDEX', name, table, fields, options, provider),
+        createUniqueIndex: (name, table, fields) => createIndexSql('UNIQUE INDEX', name, table, fields, undefined, provider),
         addColumn: (table, column) => {
             // SQLite refuses "Cannot add a UNIQUE column", so the unique is left out here
             // and added as a separate index by the caller — silently dropping it instead
@@ -255,12 +383,17 @@ const SHEETS_DIALECT = {
     quoteTable: (raw) => objectName(raw),
     supportsNamedUniqueConstraint: false,
     supportsUniqueInlineOnAddColumn: false,
+    supportsCreateOrReplaceView: false,
     tableExists: () => '',
+    viewExists: () => '',
+    viewDefinition: () => '',
     columnExists: () => '',
     uniqueConstraintExists: () => '',
     indexExists: () => '',
     columnDefinition: () => '',
     createTable: () => '',
+    createView: () => '',
+    dropView: () => '',
     createIndex: () => '',
     createUniqueIndex: () => '',
     addColumn: () => '',