@an5/orm 1.3.1 → 1.3.3

package/dist/generator/src/parser.js

@@ -7,6 +7,7 @@ exports.SchemaParser = void 0;
 exports.sqlTypeToTs = sqlTypeToTs;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const attributes_1 = require("./attributes");
 const field_types_1 = require("./field-types");
 /**
  * Maps a column type of a provider to its TypeScript type.
@@ -28,14 +29,16 @@ class SchemaParser {
         this.schemaText = '';
         this.issues = [];
         this.modelRefs = [];
+        this.viewRefs = [];
         this.models = [];
     }
     async parse() {
         this.issues = [];
         this.modelRefs = [];
+        this.viewRefs = [];
         this.models = [];
         this.loadSchema();
-        const lines = this.schemaText.split('\n');
+        const lines = (0, attributes_1.splitSchemaLines)(this.schemaText);
         const models = [];
         let currentModel = null;
         for (let line of lines) {
@@ -60,6 +63,21 @@ class SchemaParser {
                 models.push(currentModel);
                 continue;
             }
+            const viewHeaderMatch = line.match(/^view\s+(\w+)\s*\{/);
+            if (viewHeaderMatch) {
+                const viewName = viewHeaderMatch[1];
+                currentModel = {
+                    name: viewName,
+                    tableName: viewName.toLowerCase() + 's',
+                    schemaName: this.provider === 'mssql' ? 'dbo' : '',
+                    provider: this.provider,
+                    fields: [],
+                    relations: [],
+                    isView: true,
+                };
+                models.push(currentModel);
+                continue;
+            }
             if (line === '}') {
                 currentModel = null;
                 continue;
@@ -70,6 +88,11 @@ class SchemaParser {
         }
         this.models = models;
         this.resolveModelRefs();
+        const missingSql = models.filter((model) => model.isView && !model.viewSql?.trim());
+        if (missingSql.length > 0) {
+            const names = missingSql.map((model) => `"${model.name}"`).join(', ');
+            throw new Error(`View ${names} must declare @@sql("SELECT ...").`);
+        }
         // 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) {
@@ -90,35 +113,47 @@ class SchemaParser {
         }
     }
     parseModelLine(line, model) {
+        if (line.startsWith('@@sql') || line.startsWith('@@definition')) {
+            // `@@definition` is accepted as an alias: the directive names a SQL body,
+            // and both spellings are unambiguous.
+            const attribute = line.startsWith('@@sql') ? '@@sql' : '@@definition';
+            if (model.isView) {
+                const sql = (0, attributes_1.unquote)((0, attributes_1.attributeArgs)(line, attribute));
+                if (sql !== undefined)
+                    model.viewSql = sql.trim();
+            }
+            return;
+        }
         if (line.startsWith('@@map')) {
-            const mapMatch = line.match(/@@map\("(.+)"\)/);
-            if (mapMatch)
-                model.tableName = mapMatch[1];
+            const mapped = (0, attributes_1.unquote)((0, attributes_1.attributeArgs)(line, '@@map'));
+            if (mapped)
+                model.tableName = mapped;
             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();
+            // An empty string is meaningful: `@@schema("")` says "no schema", needed
+            // for databases that have no schema concept. It must not be dropped as if
+            // the directive were absent.
+            const declared = (0, attributes_1.unquote)((0, attributes_1.attributeArgs)(line, '@@schema'));
+            if (declared !== undefined)
+                model.schemaName = declared.trim();
             return;
         }
         if (line.startsWith('@@unique')) {
-            const uniqueMatch = line.match(/@@unique\(\[([\w,\s]+)\]\)/);
-            if (uniqueMatch) {
-                const fields = uniqueMatch[1].split(',').map(f => f.trim());
+            // Constraints describe stored tables; a view's shape comes from its SQL.
+            if (model.isView)
+                return;
+            const parsed = (0, attributes_1.parseIndexDirective)((0, attributes_1.attributeArgs)(line, '@@unique'));
+            if (parsed) {
                 model.compoundUniques = model.compoundUniques || [];
-                model.compoundUniques.push(fields);
+                model.compoundUniques.push(parsed.fields);
             }
             return;
         }
         if (line.startsWith('@@description')) {
-            const descMatch = line.match(/@@description\("(.+)"\)/);
-            if (descMatch)
-                model.description = descMatch[1];
+            const description = (0, attributes_1.unquote)((0, attributes_1.attributeArgs)(line, '@@description'));
+            if (description !== undefined)
+                model.description = description;
             return;
         }
         if (line.startsWith('@@'))
@@ -132,16 +167,18 @@ class SchemaParser {
         // later at the database layer, in a message unrelated to the schema.
         const resolved = (0, field_types_1.resolveFieldType)(head.type, this.provider);
         if (!resolved) {
+            if (model.isView) {
+                // A view's fields are columns of a result set, never relations.
+                this.viewRefs.push({ view: model.name, field: head.name, type: head.type });
+                return;
+            }
             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;
-        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 });
+        const hasDefault = (0, attributes_1.hasAttribute)(line, '@default') || (0, attributes_1.hasAttribute)(line, '@updatedAt') || (0, attributes_1.hasAttribute)(line, '@id');
+        const isId = (0, attributes_1.hasAttribute)(line, '@id');
+        const description = (0, attributes_1.unquote)((0, attributes_1.attributeArgs)(line, '@description'));
+        model.fields.push({ name: head.name, type: resolved.ts, sqlType: head.type, isOptional: head.isOptional, hasDefault, isId, ...(description !== undefined ? { description } : {}) });
     }
     /**
      * Settles the fields that matched no type: a name matching a model in the
@@ -155,24 +192,42 @@ class SchemaParser {
      */
     resolveModelRefs() {
         const modelNames = this.models.map((model) => model.name);
+        const tableNames = this.models.filter((model) => !model.isView).map((model) => model.name);
+        const viewNames = new Set(this.models.filter((model) => model.isView).map((model) => model.name));
+        for (const ref of this.viewRefs) {
+            this.issues.push({
+                path: `${ref.view}.${ref.field}`,
+                message: (0, field_types_1.unknownFieldTypeMessage)(ref.type, this.provider, modelNames),
+            });
+        }
+        this.viewRefs = [];
         for (const ref of this.modelRefs) {
-            if (!modelNames.includes(ref.type)) {
+            if (viewNames.has(ref.type)) {
+                // A relation carries a foreign key and generated write inputs. A view has
+                // neither, and an `include` of it would have no CreateInput to reference.
+                this.issues.push({
+                    path: `${ref.model.name}.${ref.name}`,
+                    message: `"${ref.type}" is a view and cannot be the target of a relation; select from it directly instead`,
+                });
+                continue;
+            }
+            if (!tableNames.includes(ref.type)) {
                 this.issues.push({
                     path: `${ref.model.name}.${ref.name}`,
-                    message: (0, field_types_1.unknownFieldTypeMessage)(ref.type, this.provider, modelNames),
+                    message: (0, field_types_1.unknownFieldTypeMessage)(ref.type, this.provider, tableNames),
                 });
                 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 relationArgs = (0, attributes_1.attributeArgs)(ref.line, '@relation');
+            if (relationArgs) {
+                // `@relation("name", fields: [userId], references: [id])`; the name is
+                // either positional or spelled `name:`.
+                relationName = relationArgs.match(/^\s*(?:\w+\s*:\s*)?"([^"]+)"/)?.[1] ?? '';
+                foreignKey = (relationArgs.match(/\bfields\s*:\s*\[([^\]]*)\]/)?.[1] ?? '').split(',')[0]?.trim() ?? '';
+                localKey = (relationArgs.match(/\breferences\s*:\s*\[([^\]]*)\]/)?.[1] ?? '').split(',')[0]?.trim() ?? '';
             }
-            const description = ref.line.match(/@description\("(.+)"\)/)?.[1];
+            const description = (0, attributes_1.unquote)((0, attributes_1.attributeArgs)(ref.line, '@description'));
             ref.model.relations.push({
                 name: ref.name,
                 type: ref.type,

package/dist/generator/src/pull-schema.d.ts

@@ -0,0 +1,54 @@
+/** One column as `sys.columns`/`sys.types` describe it. */
+export interface PulledColumn {
+    columnName: string;
+    dataType: string;
+    maxLength: number;
+    precision: number;
+    scale: number;
+    isNullable: boolean | number;
+}
+/**
+ * The schema type of an introspected SQL Server column.
+ *
+ * `max_length` is bytes, so the character types divide it by two; `-1` is `MAX`.
+ * Tables and views describe their columns the same way, so they share this.
+ */
+export declare function sqlServerTypeForColumn(col: PulledColumn): string;
+/**
+ * Where `keyword Name { ... }` starts and ends in a schema file.
+ *
+ * The closing brace is the one on its own line, not the first `}` anywhere: a
+ * view's SQL may contain one (`WHERE name <> '}'`) and a regex that stops there
+ * would truncate the block.
+ */
+export declare function blockRange(text: string, keyword: 'model' | 'view', name: string): {
+    start: number;
+    end: number;
+} | null;
+/** The additional key a schema block is known by, e.g. `reporting.active_users`. */
+export declare function qualifiedBlockKey(name: string, schemaName: string | undefined): string;
+/**
+ * A likely block name for an introspected object.
+ *
+ * `db:pull` names a new block after the table or view, dropping the plural `s`
+ * so `users` becomes `User`. A word that already ends in `s` but is singular
+ * (`status`, `address`, `analysis`) must keep it: stripping the character turns
+ * it into `Statu`, which reads like a typo in every generated client. Existing
+ * blocks keep their own name, so this only decides what a newly pulled object is
+ * called.
+ */
+export declare function blockNameForObject(objectName: string): string;
+/**
+ * A `view` block for a catalog view.
+ *
+ * `@@sql` gets the body, not the `CREATE VIEW` statement the catalog returns:
+ * push and migrate add the `CREATE VIEW` themselves, so storing the header would
+ * produce `CREATE OR REPLACE VIEW x AS CREATE VIEW ...`.
+ */
+export declare function buildViewBlock(input: {
+    modelName: string;
+    viewName: string;
+    schemaName: string;
+    columns: readonly PulledColumn[];
+    definition: string | null | undefined;
+}): string | null;

package/dist/generator/src/pull-schema.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlServerTypeForColumn = sqlServerTypeForColumn;
+exports.blockRange = blockRange;
+exports.qualifiedBlockKey = qualifiedBlockKey;
+exports.blockNameForObject = blockNameForObject;
+exports.buildViewBlock = buildViewBlock;
+/**
+ * Pure helpers for `db:pull`.
+ *
+ * Reading SQL Server catalogs and writing schema files lives in `pull.ts`, which
+ * starts a connection as soon as it is imported. The decisions it makes about the
+ * text — which block to replace, how a view becomes a `view` block — are here so
+ * they can be tested without a database.
+ */
+const dialect_1 = require("./dialect");
+/**
+ * The schema type of an introspected SQL Server column.
+ *
+ * `max_length` is bytes, so the character types divide it by two; `-1` is `MAX`.
+ * Tables and views describe their columns the same way, so they share this.
+ */
+function sqlServerTypeForColumn(col) {
+    let sqlType = col.dataType.toUpperCase();
+    const dt = col.dataType.toLowerCase();
+    if (dt === 'nvarchar' || dt === 'varchar') {
+        sqlType = col.maxLength === -1 ? `${sqlType.toUpperCase()}(MAX)` : `${sqlType.toUpperCase()}(${col.maxLength / 2})`;
+    }
+    else if (dt === 'char' || dt === 'nchar') {
+        sqlType = `${sqlType.toUpperCase()}(${col.maxLength / 2})`;
+    }
+    else if (dt === 'varbinary' || dt === 'binary') {
+        sqlType = col.maxLength === -1 ? `${sqlType.toUpperCase()}(MAX)` : `${sqlType.toUpperCase()}(${col.maxLength})`;
+    }
+    else if (dt === 'decimal' || dt === 'numeric') {
+        sqlType = `${sqlType.toUpperCase()}(${col.precision}, ${col.scale})`;
+    }
+    return sqlType;
+}
+/**
+ * Where `keyword Name { ... }` starts and ends in a schema file.
+ *
+ * The closing brace is the one on its own line, not the first `}` anywhere: a
+ * view's SQL may contain one (`WHERE name <> '}'`) and a regex that stops there
+ * would truncate the block.
+ */
+function blockRange(text, keyword, name) {
+    const header = new RegExp(`(^|\\n)[ \\t]*${keyword}\\s+${name}\\s*\\{`);
+    const match = header.exec(text);
+    if (!match)
+        return null;
+    const start = match.index + (match[1]?.length ?? 0);
+    const bodyStart = match.index + match[0].length;
+    const close = /(^|\n)[ \t]*\}/.exec(text.slice(bodyStart));
+    if (!close)
+        return null;
+    return { start, end: bodyStart + close.index + close[0].length };
+}
+/** The additional key a schema block is known by, e.g. `reporting.active_users`. */
+function qualifiedBlockKey(name, schemaName) {
+    return !schemaName || schemaName.toLowerCase() === 'dbo' ? name : `${schemaName}.${name}`;
+}
+/**
+ * A likely block name for an introspected object.
+ *
+ * `db:pull` names a new block after the table or view, dropping the plural `s`
+ * so `users` becomes `User`. A word that already ends in `s` but is singular
+ * (`status`, `address`, `analysis`) must keep it: stripping the character turns
+ * it into `Statu`, which reads like a typo in every generated client. Existing
+ * blocks keep their own name, so this only decides what a newly pulled object is
+ * called.
+ */
+function blockNameForObject(objectName) {
+    // `active_users` becomes `ActiveUser`, not `Active_user`: the block name is a
+    // generated type in every client, so it follows the schema's own casing.
+    const words = objectName.split(/[^A-Za-z0-9]+/).filter(Boolean);
+    const capitalized = (words.length > 0 ? words : [objectName])
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+    // `addresses`/`classes` lose `es`; `status`/`address`/`analysis` are singular
+    // and keep the `s`.
+    if (/sses$/i.test(capitalized))
+        return capitalized.slice(0, -2);
+    if (/(?:ss|us|is)$/i.test(capitalized))
+        return capitalized;
+    if (/s$/i.test(capitalized))
+        return capitalized.slice(0, -1);
+    return capitalized;
+}
+/**
+ * A `view` block for a catalog view.
+ *
+ * `@@sql` gets the body, not the `CREATE VIEW` statement the catalog returns:
+ * push and migrate add the `CREATE VIEW` themselves, so storing the header would
+ * produce `CREATE OR REPLACE VIEW x AS CREATE VIEW ...`.
+ */
+function buildViewBlock(input) {
+    const body = (0, dialect_1.viewSqlBody)(input.definition);
+    if (!body)
+        return null;
+    const lines = [`view ${input.modelName} {`];
+    for (const col of input.columns) {
+        lines.push(`  ${col.columnName} ${sqlServerTypeForColumn(col)}${col.isNullable ? '?' : ''}`);
+    }
+    if (input.viewName !== input.modelName.toLowerCase() + 's') {
+        lines.push('', `  @@map("${input.viewName}")`);
+    }
+    if (input.schemaName && input.schemaName.toLowerCase() !== 'dbo') {
+        lines.push(`  @@schema("${input.schemaName}")`);
+    }
+    lines.push('', '  @@sql("""');
+    for (const line of body.split(/\r?\n/))
+        lines.push(`    ${line}`);
+    lines.push('  """)', '}');
+    return lines.join('\n');
+}

package/dist/generator/src/push-apply.d.ts

@@ -9,7 +9,7 @@
  * and keeps the driver out of the decision making.
  */
 import { PushDialect } from './dialect';
-import { PushModel } from './push-schema';
+import { PushModel, PushView } 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`. */
@@ -26,6 +26,8 @@ export interface ApplyResult {
     columnsAdded: number;
     indexesCreated: number;
     uniqueConstraintsAdded: number;
+    /** How many views were created or replaced. */
+    viewsApplied: number;
 }
 /**
  * Creates whatever the schema has and the database does not.
@@ -34,4 +36,4 @@ export interface ApplyResult {
  * 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 declare function applySchema(models: readonly PushModel[], dialect: PushDialect, db: PushDatabase): Promise<ApplyResult>;
+export declare function applySchema(models: readonly PushModel[], dialect: PushDialect, db: PushDatabase, views?: readonly PushView[]): Promise<ApplyResult>;

package/dist/generator/src/push-apply.js

@@ -1,7 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applySchema = applySchema;
+/**
+ * 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.
+ */
+const dialect_1 = require("./dialect");
 const push_schema_1 = require("./push-schema");
+const view_order_1 = require("./view-order");
 /**
  * Creates whatever the schema has and the database does not.
  *
@@ -9,13 +21,14 @@ const push_schema_1 = require("./push-schema");
  * 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.
  */
-async function applySchema(models, dialect, db) {
+async function applySchema(models, dialect, db, views = []) {
     const result = {
         tablesCreated: 0,
         tablesAltered: 0,
         columnsAdded: 0,
         indexesCreated: 0,
         uniqueConstraintsAdded: 0,
+        viewsApplied: 0,
     };
     for (const model of models) {
         const tableName = (0, push_schema_1.qualifiedTableName)(model);
@@ -56,7 +69,9 @@ async function applySchema(models, dialect, db) {
                 // 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}`;
+                    // The same name `db:migrate` expects for this column's unique, so the
+                    // next diff sees push's artifact instead of adding another one.
+                    const indexName = field.uniqueName ?? `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}...`);
@@ -80,7 +95,6 @@ async function applySchema(models, dialect, db) {
                 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;
         }
@@ -90,10 +104,45 @@ async function applySchema(models, dialect, db) {
                 continue;
             const quoted = dialect.quote(name);
             db.log(`Creating index ${quoted} on table ${sqlTableName}...`);
-            await db.execute(dialect.createIndex(quoted, sqlTableName, quoteFields(directive.fields)));
+            await db.execute(dialect.createIndex(quoted, sqlTableName, quoteFields(directive.fields), {
+                includeFields: directive.includeFields ? quoteFields(directive.includeFields) : undefined,
+                filter: directive.filter,
+                options: directive.options,
+            }));
             result.indexesCreated += 1;
         }
     }
+    // Views are applied after every table: a view may select from a table this same
+    // push created, and SQL Server validates the reference while compiling it.
+    // Within the views, a dependent view has to come after the one it reads.
+    const orderedViews = (0, view_order_1.orderViewsByDependency)(views.map((view) => ({
+        view,
+        names: [(0, push_schema_1.qualifiedViewName)(view), view.viewName],
+        sql: view.sql,
+    })));
+    if (orderedViews.cyclic) {
+        // The definitions cannot all exist at once; the database reports which one
+        // is missing, which is more useful than a generic ordering error here.
+        db.log('Warning: view definitions reference each other in a cycle; keeping schema order.');
+    }
+    for (const { view } of orderedViews.ordered) {
+        const viewName = (0, push_schema_1.qualifiedViewName)(view);
+        const sqlViewName = dialect.quoteTable(viewName);
+        db.log(`Processing view ${sqlViewName}...`);
+        const rows = await db.query(dialect.viewDefinition(viewName));
+        const existing = rows[0];
+        if (existing && (0, dialect_1.normalizeViewSql)(existing.definition) === (0, dialect_1.normalizeViewSql)(view.sql)) {
+            // The catalog and the schema agree; recreating would just churn dependencies.
+            continue;
+        }
+        if (existing && !dialect.supportsCreateOrReplaceView) {
+            db.log(`Dropping view ${sqlViewName} before recreating it...`);
+            await db.execute(dialect.dropView(sqlViewName));
+        }
+        db.log(`Creating view ${sqlViewName}...`);
+        await db.execute(dialect.createView(sqlViewName, view.sql));
+        result.viewsApplied += 1;
+    }
     return result;
 }
 /**

package/dist/generator/src/push-schema.d.ts

@@ -1,12 +1,3 @@
-/**
- * Reading `.an5` files for `db:push`.
- *
- * `SchemaParser` and `parseSchemaText` cover the generators and `db:migrate`;
- * this is the third reader, and it exists because push needs a shape of its own:
- * raw `@default` expressions rather than rendered SQL, and the schema a table
- * lands in. It is kept here rather than inline in `push.ts` so the mapping from
- * schema text to a column can be tested without a database.
- */
 import { FieldTypeIssue, Provider } from './field-types';
 /** A column, as push needs it: the type as written plus what the dialect renders. */
 export interface PushField {
@@ -15,6 +6,8 @@ export interface PushField {
     isOptional: boolean;
     isId: boolean;
     isUnique: boolean;
+    /** `@unique(map: "…")`, so push and migrate create the same artifact name. */
+    uniqueName?: string | undefined;
     /** The `@default(...)` expression, not SQL: only the dialect knows the spelling. */
     defaultExpr?: string | undefined;
 }
@@ -31,6 +24,21 @@ export interface PushModel {
     /** `@@index([a, b])`, as field lists. */
     indexes: PushIndex[];
 }
+/**
+ * A `view` block, as push needs it.
+ *
+ * `fields` describe the view's result columns for validation and generated
+ * clients; the DDL itself is `sql`, the `@@sql("...")` body.
+ */
+export interface PushView {
+    name: string;
+    /** The database view name; `@@map` may rename it independently. */
+    viewName: string;
+    schema: string;
+    declaredSchema?: string | undefined;
+    fields: PushField[];
+    sql: string;
+}
 /**
  * The schema a model lands in when the schema file does not say: none, for every
  * provider, so the name goes wherever the connection resolves.
@@ -58,6 +66,8 @@ export interface PushIndex {
 }
 export interface PushSchema {
     models: PushModel[];
+    /** `view` blocks, applied after the tables they read from. */
+    views: PushView[];
     /** Field types the provider does not have; empty when the schema is valid. */
     issues: FieldTypeIssue[];
 }
@@ -91,3 +101,5 @@ export declare function parsePushSchema(text: string, provider: Provider): PushS
  */
 export declare function safeIdentifierName(raw: string): string;
 export declare function qualifiedTableName(model: PushModel): string;
+/** The view name to create, qualified only when the view declared a schema. */
+export declare function qualifiedViewName(view: PushView): string;