@an5/orm 1.3.2 → 1.3.4

package/generator/src/attributes.ts

@@ -0,0 +1,231 @@
+/**
+ * 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.
+ */
+
+/** Finds a matching `)` for the `(` at `open`, ignoring parentheses inside quotes. */
+function closingParenthesis(line: string, open: number): number {
+  let depth = 0;
+  let quote: string | null = 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. */
+export function hasAttribute(line: string, name: string): boolean {
+  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.
+ */
+export function attributeArgs(line: string, name: string): string | undefined {
+  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. */
+export function unquote(value: string | undefined): string | undefined {
+  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: string): boolean {
+  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.
+ */
+export function splitSchemaLines(text: string): string[] {
+  const lines: string[] = [];
+  let pending: string | null = 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")`.
+ */
+export function stringOption(args: string | undefined, key: string): string | undefined {
+  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]`. */
+export function fieldListOption(args: string | undefined, key: string): string[] | undefined {
+  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);
+}
+
+/** One `@@unique` or `@@index` directive, with the options it accepts. */
+export interface IndexDirective {
+  fields: string[];
+  name?: string;
+  includeFields?: string[];
+  filter?: string;
+  options?: string;
+}
+
+/**
+ * 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.
+ */
+export function parseIndexDirective(args: string | undefined): IndexDirective | null {
+  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: IndexDirective = { 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: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/generator/src/code-generator.ts

@@ -60,12 +60,28 @@ 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.writeFileSync(path.join(this.outputDir, 'base.ts'), baseTs);
   }
 
   private generateModelFile(model: 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) {
@@ -121,17 +137,21 @@ export interface TableClient<T, WhereInput = any, _Select = any, Include = any,
     }
     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('; ');
@@ -139,7 +159,11 @@ export interface TableClient<T, WhereInput = any, _Select = any, Include = any,
     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.writeFileSync(path.join(this.outputDir, `${model.name}.ts`), content);
   }
@@ -173,17 +197,23 @@ 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`;
@@ -195,9 +225,10 @@ export interface TableClient<T, WhereInput = any, _Select = any, Include = any,
     const addedProps = new Set<string>();
     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/generator/src/config.ts

@@ -417,8 +417,8 @@ export function resolveConnectionString(
  *
  * 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 function detectProvider(connectionString: string | undefined | null): Provider {
   // Lower-cased: a URI scheme is case-insensitive, so `MySQL://` is the same
@@ -430,7 +430,9 @@ export function detectProvider(connectionString: string | undefined | null): Pro
   if (cs.startsWith('googlesheets://')) return 'googlesheets';
   if (cs.startsWith('postgres://') || cs.startsWith('postgresql://')) return 'postgres';
   if (cs.startsWith('mysql://') || cs.startsWith('mariadb://')) return 'mysql';
-  if (SQLITE_FILE_SUFFIXES.some((suffix) => cs.endsWith(suffix))) return 'sqlite';
+  if (cs === ':memory:' || cs.startsWith('sqlite:') || SQLITE_FILE_SUFFIXES.some((suffix) => cs.endsWith(suffix))) {
+    return 'sqlite';
+  }
   return DEFAULT_PROVIDER;
 }
 

package/generator/src/dialect.ts

@@ -24,7 +24,7 @@ function objectName(raw: string): string {
 function splitQualified(raw: string): { schema: string | undefined; name: string } {
   const parts = raw.replace(/[\[\]"`]/g, '').split('.').filter(Boolean);
   if (parts.length >= 2) {
-    return { schema: parts[parts.length - 2], name: parts[parts.length - 1] };
+    return { schema: parts[parts.length - 2], name: parts[parts.length - 1]! };
   }
   return { schema: undefined, name: parts[0] ?? raw };
 }
@@ -50,10 +50,25 @@ 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. */
@@ -80,6 +95,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. */
@@ -89,7 +114,17 @@ 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;
@@ -154,6 +189,86 @@ function buildTableExists(provider: Provider): (raw: string) => string {
   };
 }
 
+/**
+ * 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: Provider): (raw: string) => string {
+  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: Provider): (raw: string) => string {
+  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.
+ */
+export function viewSqlBody(sql: string | null | undefined): string {
+  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.
+ */
+export function normalizeViewSql(sql: string | null | undefined): string {
+  return viewSqlBody(sql).replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
 function buildColumnExists(provider: Provider): (raw: string, column: string) => string {
   return (raw, column) => {
     const { schema, name } = splitQualified(raw);
@@ -281,6 +396,47 @@ function identityKeyword(column: ColumnSpec, provider: Provider): string {
   }
 }
 
+/**
+ * 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: 'INDEX' | 'UNIQUE INDEX',
+  quotedName: string,
+  quotedTable: string,
+  quotedFields: string[],
+  options: IndexOptions | undefined,
+  provider: Provider,
+): string {
+  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: Provider, quote: (name: string) => string): PushDialect {
   const supportsUniqueInlineOnAddColumn = provider !== 'sqlite';
   const quoteTable = (raw: string): string => {
@@ -303,7 +459,14 @@ function createDialect(provider: Provider, quote: (name: string) => string): Pus
       ? `${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}` : '';
 
@@ -321,14 +484,29 @@ function createDialect(provider: Provider, quote: (name: string) => string): Pus
     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
@@ -354,12 +532,17 @@ const SHEETS_DIALECT: PushDialect = {
   quoteTable: (raw) => objectName(raw),
   supportsNamedUniqueConstraint: false,
   supportsUniqueInlineOnAddColumn: false,
+  supportsCreateOrReplaceView: false,
   tableExists: () => '',
+  viewExists: () => '',
+  viewDefinition: () => '',
   columnExists: () => '',
   uniqueConstraintExists: () => '',
   indexExists: () => '',
   columnDefinition: () => '',
   createTable: () => '',
+  createView: () => '',
+  dropView: () => '',
   createIndex: () => '',
   createUniqueIndex: () => '',
   addColumn: () => '',