@an5/orm 1.0.9 → 1.1.1

package/dist/generator/src/index.js

@@ -4,12 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+const field_types_1 = require("./field-types");
 const parser_1 = require("./parser");
 const code_generator_1 = require("./code-generator");
 const metadata_generator_1 = require("./metadata-generator");
 const python_generator_1 = require("./python-generator");
 const dotnet_generator_1 = require("./dotnet-generator");
 const golang_generator_1 = require("./golang-generator");
+const rust_generator_1 = require("./rust-generator");
 const fs_1 = __importDefault(require("fs"));
 function clearGeneratedFiles(outputDir, extension) {
     if (!fs_1.default.existsSync(outputDir)) {
@@ -26,61 +29,81 @@ function clearGeneratedFiles(outputDir, extension) {
         }
     }
 }
+function clearGeneratedPythonFiles(outputDir) {
+    if (!fs_1.default.existsSync(outputDir)) {
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
+        return;
+    }
+    // Delete generated .py files but preserve hand-maintained adapter.
+    const preserve = new Set(['an5_adapter.py']);
+    for (const entry of fs_1.default.readdirSync(outputDir)) {
+        const fullPath = path_1.default.join(outputDir, entry);
+        const stat = fs_1.default.statSync(fullPath);
+        if (stat.isDirectory())
+            continue;
+        if (entry.endsWith('.py') && !preserve.has(entry)) {
+            fs_1.default.unlinkSync(fullPath);
+        }
+    }
+}
 async function main() {
-    let rootDir = process.cwd();
-    let config = {};
+    // Loaded through the validating loader, so a mistyped key or a wrong type
+    // stops here instead of quietly generating somewhere else.
+    let config;
     try {
-        let configPath = path_1.default.join(rootDir, 'an5Orm.config.js');
-        if (!fs_1.default.existsSync(configPath)) {
-            configPath = path_1.default.join(rootDir, 'an5Orm.config.cjs');
-        }
-        if (!fs_1.default.existsSync(configPath)) {
-            configPath = path_1.default.join(rootDir, '..', 'an5Orm.config.js');
-        }
-        if (!fs_1.default.existsSync(configPath)) {
-            configPath = path_1.default.join(rootDir, '..', 'an5Orm.config.cjs');
-        }
-        if (fs_1.default.existsSync(configPath)) {
-            config = require(configPath);
-            rootDir = path_1.default.dirname(configPath);
-        }
-        else if (fs_1.default.existsSync(path_1.default.join(rootDir, '..', 'an5Schema'))) {
-            rootDir = path_1.default.resolve(rootDir, '..');
-        }
+        config = (0, config_1.loadConfig)();
     }
     catch (err) {
+        if (err instanceof config_1.ConfigError) {
+            console.error(`❌ ${err.message}:`);
+            console.error((0, config_1.formatIssues)(err.issues));
+            process.exit(1);
+        }
         console.warn('⚠️ Could not load an5Orm.config.js/.cjs, using defaults.', err);
+        config = (0, config_1.loadConfig)(path_1.default.join(process.cwd(), 'no-such-dir'));
     }
-    const schemaDir = path_1.default.resolve(rootDir, config.schemaDir || 'an5Schema');
-    const outputTypesDir = path_1.default.resolve(rootDir, config.outputs?.typescript?.outputDir || 'an5Client/typescript');
-    const outputMetadataPath = path_1.default.resolve(rootDir, config.outputs?.typescript?.metadataFile || 'an5Client/typescript/an5Metadata.ts');
-    const outputPythonMetadataPath = path_1.default.resolve(rootDir, config.outputs?.python?.metadataFile || 'an5Client/python/an5_metadata.py');
-    const outputDotnetDir = path_1.default.resolve(rootDir, config.outputs?.dotnet?.outputDir || 'an5Client/dotnet');
-    const outputGolangDir = path_1.default.resolve(rootDir, config.outputs?.golang?.outputDir || 'an5Client/golang');
+    const { rootDir } = config;
+    const schemaDir = config.outputs.schemaDir;
+    const outputTypesDir = config.outputs.typescriptDir;
+    const outputMetadataPath = config.outputs.typescriptMetadataFile;
+    const outputPythonMetadataPath = config.outputs.pythonMetadataFile;
+    const outputDotnetDir = config.outputs.dotnetDir;
+    const outputGolangDir = config.outputs.golangDir;
+    const outputRustDir = config.outputs.rustDir;
+    const generateMetadata = config.config.generation.generateMetadata;
     console.log('🚀 Starting ORM generation...');
+    // The target provider comes from the connection string: both the allowed
+    // field types and the SQL follow it, instead of one shared list.
+    const provider = (0, config_1.providerFromConfig)(config.config, process.env);
+    console.log(`🗄️  Provider: ${field_types_1.PROVIDER_LABELS[provider]} (${provider})`);
     try {
         clearGeneratedFiles(outputTypesDir, '.ts');
         clearGeneratedFiles(outputDotnetDir, '.cs');
         clearGeneratedFiles(outputGolangDir, '.go');
-        if (fs_1.default.existsSync(outputMetadataPath)) {
+        clearGeneratedFiles(path_1.default.join(outputRustDir, 'src'), '.rs');
+        const pythonDirEarly = path_1.default.dirname(outputPythonMetadataPath);
+        clearGeneratedPythonFiles(pythonDirEarly);
+        if (config.config.generation.generateMetadata && fs_1.default.existsSync(outputMetadataPath)) {
             fs_1.default.unlinkSync(outputMetadataPath);
         }
-        if (fs_1.default.existsSync(outputPythonMetadataPath)) {
-            fs_1.default.unlinkSync(outputPythonMetadataPath);
-        }
-        const parser = new parser_1.SchemaParser(schemaDir);
+        const parser = new parser_1.SchemaParser(schemaDir, provider);
         const models = await parser.parse();
         console.log(`📦 Parsed ${models.length} models from schema.`);
         const codeGen = new code_generator_1.CodeGenerator(outputTypesDir);
         codeGen.generate(models);
         console.log(`✨ Generated modular types in ${outputTypesDir}`);
-        const metadataDir = path_1.default.dirname(outputMetadataPath);
-        if (!fs_1.default.existsSync(metadataDir)) {
-            fs_1.default.mkdirSync(metadataDir, { recursive: true });
+        if (generateMetadata) {
+            const metadataDir = path_1.default.dirname(outputMetadataPath);
+            if (!fs_1.default.existsSync(metadataDir)) {
+                fs_1.default.mkdirSync(metadataDir, { recursive: true });
+            }
+            const metadataGen = new metadata_generator_1.MetadataGenerator(outputMetadataPath);
+            metadataGen.generate(models);
+            console.log(`✨ Generated metadata in ${outputMetadataPath}`);
+        }
+        else {
+            console.log('⏭ Skipping metadata (generation.generateMetadata is false)');
         }
-        const metadataGen = new metadata_generator_1.MetadataGenerator(outputMetadataPath);
-        metadataGen.generate(models);
-        console.log(`✨ Generated metadata in ${outputMetadataPath}`);
         const pythonDir = path_1.default.dirname(outputPythonMetadataPath);
         if (!fs_1.default.existsSync(pythonDir)) {
             fs_1.default.mkdirSync(pythonDir, { recursive: true });
@@ -94,9 +117,19 @@ async function main() {
         const golangGen = new golang_generator_1.GolangGenerator(outputGolangDir);
         golangGen.generate(models);
         console.log(`✨ Generated Golang models in ${outputGolangDir}`);
+        const rustGen = new rust_generator_1.RustGenerator(outputRustDir);
+        rustGen.generate(models);
+        console.log(`✨ Generated Rust client in ${outputRustDir}`);
         console.log('✅ ORM generation completed successfully.');
     }
     catch (error) {
+        // Print every bad field type with its provider, instead of the parser's
+        // nested error object.
+        if (error instanceof field_types_1.FieldTypeError) {
+            console.error(`❌ ${error.message}:`);
+            console.error((0, config_1.formatIssues)(error.issues));
+            process.exit(1);
+        }
         console.error('❌ ORM generation failed:', error);
         process.exit(1);
     }

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataGenerator = void 0;
 const fs_1 = __importDefault(require("fs"));
+const types_1 = require("./types");
 class MetadataGenerator {
     constructor(outputPath, relationImport = 'import type { RelationDef } from "@an5/orm";') {
         this.outputPath = outputPath;
@@ -16,7 +17,7 @@ class MetadataGenerator {
         metaContent += 'export const modelToTable: Record<string, string> = {\n';
         for (const model of models) {
             const props = this.getAllPropertyVariations(model.name);
-            const fullTableName = `[${model.schemaName}].[${model.tableName}]`;
+            const fullTableName = (0, types_1.bracketedTableName)(model);
             for (const prop of props) {
                 metaContent += `  ${prop}: "${fullTableName}",\n`;
             }

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

@@ -1,11 +1,37 @@
 import { Model } from './types';
-export declare function sqlTypeToTs(sqlType: string): string;
+import { Provider } from './field-types';
+/**
+ * Maps a column type of a provider to its TypeScript type.
+ *
+ * `provider` defaults to SQL Server so existing callers keep their behaviour;
+ * the generator passes the provider derived from the connection string.
+ */
+export declare function sqlTypeToTs(sqlType: string, provider?: Provider): string;
 export declare class SchemaParser {
     private schemaDir;
+    private provider;
     private schemaText;
-    constructor(schemaDir: string);
+    private issues;
+    private modelRefs;
+    private models;
+    /**
+     * @param schemaDir directory holding the `.an5` files
+     * @param provider target database; decides which field types are valid
+     */
+    constructor(schemaDir: string, provider?: Provider);
     parse(): Promise<Model[]>;
     private loadSchema;
     private parseModelLine;
+    /**
+     * Settles the fields that matched no type: a name matching a model in the
+     * schema is a relation, anything else is a bad type — reported with the
+     * provider name and a suggestion.
+     *
+     * The decision has to wait for the whole schema, because a relation may point
+     * at a model declared later. Every upper-case token used to count as a
+     * relation, so `INTEGER` written for SQL Server became a relation to a model
+     * named `INTEGER` and nothing ever complained.
+     */
+    private resolveModelRefs;
     private postProcessRelations;
 }

package/dist/generator/src/parser.js

@@ -7,67 +7,33 @@ exports.SchemaParser = void 0;
 exports.sqlTypeToTs = sqlTypeToTs;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-// SQL Server type → TypeScript type mapping
-const AN5_TO_TS = {
-    // String types
-    'NVARCHAR': 'string',
-    'VARCHAR': 'string',
-    'CHAR': 'string',
-    'NCHAR': 'string',
-    'TEXT': 'string',
-    'NTEXT': 'string',
-    'XML': 'string',
-    // Numeric types
-    'INT': 'number',
-    'SMALLINT': 'number',
-    'TINYINT': 'number',
-    'BIGINT': 'number | bigint',
-    'FLOAT': 'number',
-    'REAL': 'number',
-    'DECIMAL': 'number',
-    'NUMERIC': 'number',
-    'MONEY': 'number',
-    'SMALLMONEY': 'number',
-    // Boolean
-    'BIT': 'boolean',
-    // Date types
-    'DATETIME': 'Date',
-    'DATETIME2': 'Date',
-    'SMALLDATETIME': 'Date',
-    'DATE': 'Date',
-    'TIME': 'Date',
-    'DATETIMEOFFSET': 'Date',
-    // Binary types
-    'VARBINARY': 'Buffer',
-    'BINARY': 'Buffer',
-    'IMAGE': 'Buffer',
-    // Other
-    'UNIQUEIDENTIFIER': 'string',
-    'SQL_VARIANT': 'any',
-    'ROWVERSION': 'Buffer',
-    'HIERARCHYID': 'string',
-    'GEOGRAPHY': 'string',
-    'GEOMETRY': 'string',
-    'VECTOR': 'number[] | string',
-};
-// Parse base type from "NVARCHAR(255)" → "NVARCHAR"
-function parseSqlType(raw) {
-    const match = raw.match(/^(\w+)(?:\((.+)\))?$/);
-    if (!match)
-        return { base: raw, params: '' };
-    return { base: match[1].toUpperCase(), params: match[2] || '' };
-}
-// Map SQL Server type to TypeScript type
-function sqlTypeToTs(sqlType) {
-    const { base } = parseSqlType(sqlType);
-    return AN5_TO_TS[base] || 'any';
+const field_types_1 = require("./field-types");
+/**
+ * Maps a column type of a provider to its TypeScript type.
+ *
+ * `provider` defaults to SQL Server so existing callers keep their behaviour;
+ * the generator passes the provider derived from the connection string.
+ */
+function sqlTypeToTs(sqlType, provider = field_types_1.DEFAULT_PROVIDER) {
+    return (0, field_types_1.resolveFieldType)(sqlType, provider)?.ts ?? 'any';
 }
 class SchemaParser {
-    constructor(schemaDir) {
+    /**
+     * @param schemaDir directory holding the `.an5` files
+     * @param provider target database; decides which field types are valid
+     */
+    constructor(schemaDir, provider = field_types_1.DEFAULT_PROVIDER) {
         this.schemaDir = schemaDir;
+        this.provider = provider;
         this.schemaText = '';
+        this.issues = [];
+        this.modelRefs = [];
+        this.models = [];
     }
     async parse() {
+        this.issues = [];
+        this.modelRefs = [];
+        this.models = [];
         this.loadSchema();
         const lines = this.schemaText.split('\n');
         const models = [];
@@ -82,7 +48,12 @@ class SchemaParser {
                 currentModel = {
                     name: modelName,
                     tableName: modelName.toLowerCase() + 's',
-                    schemaName: 'dbo',
+                    // SQL Server's default schema, and only SQL Server's. For SQLite or MySQL
+                    // an unqualified name is what the connection resolves, and for PostgreSQL
+                    // it follows `search_path` — the same rule `db:push` now uses, so the
+                    // generated client and the pushed table cannot drift apart.
+                    schemaName: this.provider === 'mssql' ? 'dbo' : '',
+                    provider: this.provider,
                     fields: [],
                     relations: []
                 };
@@ -97,6 +68,13 @@ class SchemaParser {
                 this.parseModelLine(line, currentModel);
             }
         }
+        this.models = models;
+        this.resolveModelRefs();
+        // Every bad type is reported at once, so one pass over the schema is enough
+        // instead of re-running the generator after every line.
+        if (this.issues.length > 0) {
+            throw new field_types_1.FieldTypeError(this.provider, this.issues);
+        }
         this.postProcessRelations(models);
         return models;
     }
@@ -119,9 +97,13 @@ class SchemaParser {
             return;
         }
         if (line.startsWith('@@schema')) {
-            const schemaMatch = line.match(/@@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];
+                model.schemaName = schemaMatch[1].trim();
             return;
         }
         if (line.startsWith('@@unique')) {
@@ -141,48 +123,68 @@ class SchemaParser {
         }
         if (line.startsWith('@@'))
             return;
-        const parts = line.split(/\s+/);
-        const fieldName = parts[0];
-        let fieldType = parts[1];
-        if (!fieldName || !fieldType)
+        const head = (0, field_types_1.readFieldLineHead)(line);
+        if (!head)
+            return;
+        // No table entry for this provider. This used to fall through to
+        // `tsType = 'any'` (or, worse, become a relation to a model that does not
+        // exist) and the client was still generated; the failure only surfaced
+        // later at the database layer, in a message unrelated to the schema.
+        const resolved = (0, field_types_1.resolveFieldType)(head.type, this.provider);
+        if (!resolved) {
+            this.modelRefs.push({ model, name: head.name, type: head.type, isArray: head.isArray, isOptional: head.isOptional, line });
             return;
-        const isArray = fieldType.endsWith('[]');
-        const isOptional = fieldType.endsWith('?');
-        const cleanType = fieldType.replace('[]', '').replace('?', '');
-        // Parse SQL Server type (e.g., "NVARCHAR(255)" → base="NVARCHAR")
-        const { base: sqlBase } = parseSqlType(cleanType);
-        let tsType = 'any';
-        let isRelation = false;
-        // Check if it's a known SQL Server type
-        if (AN5_TO_TS[sqlBase]) {
-            tsType = sqlTypeToTs(cleanType);
-        }
-        else if (cleanType[0] === cleanType[0].toUpperCase() && !cleanType.includes('(')) {
-            // Uppercase without parens = likely a relation to another model
-            tsType = cleanType;
-            isRelation = true;
         }
-        if (isRelation) {
+        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 });
+    }
+    /**
+     * Settles the fields that matched no type: a name matching a model in the
+     * schema is a relation, anything else is a bad type — reported with the
+     * provider name and a suggestion.
+     *
+     * The decision has to wait for the whole schema, because a relation may point
+     * at a model declared later. Every upper-case token used to count as a
+     * relation, so `INTEGER` written for SQL Server became a relation to a model
+     * named `INTEGER` and nothing ever complained.
+     */
+    resolveModelRefs() {
+        const modelNames = this.models.map((model) => model.name);
+        for (const ref of this.modelRefs) {
+            if (!modelNames.includes(ref.type)) {
+                this.issues.push({
+                    path: `${ref.model.name}.${ref.name}`,
+                    message: (0, field_types_1.unknownFieldTypeMessage)(ref.type, this.provider, modelNames),
+                });
+                continue;
+            }
             let foreignKey = '', localKey = '', relationName = '';
-            const nameMatch = line.match(/@relation\("(\w+)"/);
+            const nameMatch = ref.line.match(/@relation\("(\w+)"/);
             if (nameMatch)
                 relationName = nameMatch[1];
-            const relationMatch = line.match(/@relation\((?:.*fields:\s*\[(\w+)\],)?\s*(?:.*references:\s*\[(\w+)\],?)?.*\)/);
+            const relationMatch = ref.line.match(/@relation\((?:.*fields:\s*\[(\w+)\],)?\s*(?:.*references:\s*\[(\w+)\],?)?.*\)/);
             if (relationMatch) {
                 foreignKey = relationMatch[1] || '';
                 localKey = relationMatch[2] || '';
             }
-            model.relations.push({ name: fieldName, type: tsType, isArray, isOptional, foreignKey, localKey, relationName });
-        }
-        else {
-            const hasDefault = line.includes('@default') || line.includes('@updatedAt') || line.includes('@id');
-            const isId = line.includes('@id');
-            let description;
-            const descMatch = line.match(/@description\("(.+)"\)/);
-            if (descMatch)
-                description = descMatch[1];
-            model.fields.push({ name: fieldName, type: tsType, sqlType: cleanType, isOptional, hasDefault, isId, description });
+            const description = ref.line.match(/@description\("(.+)"\)/)?.[1];
+            ref.model.relations.push({
+                name: ref.name,
+                type: ref.type,
+                isArray: ref.isArray,
+                isOptional: ref.isOptional,
+                foreignKey,
+                localKey,
+                relationName,
+                ...(description ? { description } : {}),
+            });
         }
+        this.modelRefs = [];
     }
     postProcessRelations(models) {
         for (const model of models) {

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

@@ -0,0 +1,37 @@
+/**
+ * Applying a schema to a database: what `db:push` does once the schema is read.
+ *
+ * Kept out of `push.ts` so the sequence can be run against a real database in a
+ * test — the CLI needs a live server, and a test that re-implements the sequence
+ * instead of calling it proves only that the copy works.
+ *
+ * The database is two functions rather than the adapter, which keeps this testable
+ * and keeps the driver out of the decision making.
+ */
+import { PushDialect } from './dialect';
+import { PushModel } from './push-schema';
+/** The two things this needs from a database connection. */
+export interface PushDatabase {
+    /** Runs a query and returns its rows; existence checks are `length > 0`. */
+    query(sql: string): Promise<readonly unknown[]>;
+    /** Runs one statement. */
+    execute(sql: string): Promise<void>;
+    /** Progress, so the CLI prints what it is doing. */
+    log(message: string): void;
+}
+export interface ApplyResult {
+    /** How many tables were created, and how many altered. */
+    tablesCreated: number;
+    tablesAltered: number;
+    columnsAdded: number;
+    indexesCreated: number;
+    uniqueConstraintsAdded: number;
+}
+/**
+ * Creates whatever the schema has and the database does not.
+ *
+ * The order is deliberate: a table first, then missing columns, then unique
+ * constraints and indexes — a unique over a column that does not exist yet fails.
+ * Everything is checked before it is created, so running it twice changes nothing.
+ */
+export declare function applySchema(models: readonly PushModel[], dialect: PushDialect, db: PushDatabase): Promise<ApplyResult>;

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySchema = applySchema;
+const push_schema_1 = require("./push-schema");
+/**
+ * Creates whatever the schema has and the database does not.
+ *
+ * The order is deliberate: a table first, then missing columns, then unique
+ * constraints and indexes — a unique over a column that does not exist yet fails.
+ * Everything is checked before it is created, so running it twice changes nothing.
+ */
+async function applySchema(models, dialect, db) {
+    const result = {
+        tablesCreated: 0,
+        tablesAltered: 0,
+        columnsAdded: 0,
+        indexesCreated: 0,
+        uniqueConstraintsAdded: 0,
+    };
+    for (const model of models) {
+        const tableName = (0, push_schema_1.qualifiedTableName)(model);
+        const sqlTableName = dialect.quoteTable(tableName);
+        const quoteFields = (fields) => fields.map((field) => dialect.quote(field));
+        db.log(`Processing table ${sqlTableName}...`);
+        const safeName = (0, push_schema_1.safeIdentifierName)(model.tableName);
+        // SQLite has no named unique constraints — a UNIQUE there becomes an index the
+        // engine names itself — so the unique index carries our name instead, and that
+        // name is what the existence check can look for.
+        const compoundUniques = model.compoundUniques.map((directive, idx) => ({
+            name: (0, push_schema_1.directiveName)(directive, model.tableName, 'compound', idx),
+            fields: directive.fields,
+            directive,
+        }));
+        const tableExists = (await db.query(dialect.tableExists(tableName))).length > 0;
+        if (!tableExists) {
+            db.log(`Creating table ${sqlTableName}...`);
+            const columnDefs = model.fields.map((field) => dialect.columnDefinition(field));
+            for (const entry of compoundUniques) {
+                if (!dialect.supportsNamedUniqueConstraint)
+                    continue;
+                const fieldsStr = quoteFields(entry.fields).join(', ');
+                columnDefs.push(`CONSTRAINT ${dialect.quote(entry.name)} UNIQUE (${fieldsStr})`);
+            }
+            await db.execute(dialect.createTable(sqlTableName, columnDefs));
+            db.log(`✅ Table ${sqlTableName} created.`);
+            result.tablesCreated += 1;
+        }
+        else {
+            for (const field of model.fields) {
+                const columnExists = (await db.query(dialect.columnExists(tableName, field.name))).length > 0;
+                if (columnExists)
+                    continue;
+                db.log(`Adding column ${dialect.quote(field.name)} to table ${sqlTableName}...`);
+                await db.execute(dialect.addColumn(sqlTableName, field));
+                result.columnsAdded += 1;
+                // A new `@unique` column needs its unique too, and on SQLite that cannot
+                // ride along with the ADD COLUMN — SQLite refuses to add a UNIQUE column.
+                if (field.isUnique && !field.isId && !dialect.supportsUniqueInlineOnAddColumn) {
+                    const indexName = `UQ_${safeName}_${field.name}`;
+                    const quoted = dialect.quote(indexName);
+                    if ((await db.query(dialect.uniqueConstraintExists(tableName, indexName))).length === 0) {
+                        db.log(`Creating unique index ${quoted} on table ${sqlTableName}...`);
+                        await db.execute(dialect.createUniqueIndex(quoted, sqlTableName, quoteFields([field.name])));
+                        result.uniqueConstraintsAdded += 1;
+                    }
+                }
+            }
+            result.tablesAltered += 1;
+        }
+        // Unique constraints that are not part of the column definitions above.
+        for (const entry of compoundUniques) {
+            if (await hasUniqueConstraint(db, dialect, tableName, entry.name))
+                continue;
+            const quoted = dialect.quote(entry.name);
+            if (dialect.supportsNamedUniqueConstraint) {
+                db.log(`Adding compound unique constraint ${quoted} to table ${sqlTableName}...`);
+                await db.execute(dialect.addUniqueConstraint(quoted, sqlTableName, quoteFields(entry.fields)));
+            }
+            else {
+                db.log(`Creating unique index ${quoted} on table ${sqlTableName}...`);
+                await db.execute(dialect.createUniqueIndex(quoted, sqlTableName, quoteFields(entry.fields)));
+                result.indexesCreated += 1;
+                result.uniqueConstraintsAdded += 1;
+            }
+            result.uniqueConstraintsAdded += 1;
+        }
+        for (const [idx, directive] of model.indexes.entries()) {
+            const name = (0, push_schema_1.directiveName)(directive, model.tableName, 'index', idx);
+            if ((await db.query(dialect.indexExists(tableName, name))).length > 0)
+                continue;
+            const quoted = dialect.quote(name);
+            db.log(`Creating index ${quoted} on table ${sqlTableName}...`);
+            await db.execute(dialect.createIndex(quoted, sqlTableName, quoteFields(directive.fields)));
+            result.indexesCreated += 1;
+        }
+    }
+    return result;
+}
+/**
+ * Whether the unique is already there.
+ *
+ * A compound unique created inside `CREATE TABLE` has no separate object to look
+ * for on the providers that keep them, so it is treated as present once the table
+ * exists; the per-column uniques inside a column definition are handled with the
+ * column above.
+ */
+async function hasUniqueConstraint(db, dialect, tableName, name) {
+    return (await db.query(dialect.uniqueConstraintExists(tableName, name))).length > 0;
+}