ormbridge 0.8.0 → 0.10.0

package/dist/emitters/efcore.js

@@ -0,0 +1,686 @@
+import { findModel } from '../ir.js';
+import { toSnakeCase } from '../naming.js';
+import { prismaOnlyWarnings } from '../prismaOnlyConstructs.js';
+import { normalizeSchema } from '../transforms.js';
+import { buildColumn, isPostgres, } from './efcoreColumns.js';
+import { DBCONTEXT_MEMBER_NAMES, DEFAULT_EFCORE_NAMESPACE, RESERVED_MEMBER_NAMES, RESERVED_TYPE_NAMES, pascalIdentifier, navigationName, pluralize, repairedIdentifier, uniqueName, } from './efcoreNames.js';
+import { renderFiles } from './efcoreRender.js';
+/**
+ * Writes Entity Framework Core 8 models (C#, `#nullable enable`): one entity class per model, a C# enum per
+ * enum, and an `AppDbContext` with a `DbSet<T>` for every entity. Two styles:
+ *
+ * - `annotations` (the default) puts what data annotations can say on the classes (`[Table]`, `[Column]`,
+ *   `[Key]`, `[MaxLength]`, `[Precision]`, `[Index]`, `[ForeignKey]`, `[InverseProperty]`, `[DatabaseGenerated]`)
+ *   and writes the rest (defaults, enum conversions, delete behaviors, many-to-many join tables) with the fluent
+ *   API in `OnModelCreating`.
+ * - `fluent` writes plain classes and one `IEntityTypeConfiguration<T>` per entity that holds all of the mapping.
+ *
+ * Every table, column, key, index and foreign key is written explicitly, so the output creates the schema of the
+ * IR and the EF Core reader reads it back.
+ */
+export { DEFAULT_EFCORE_NAMESPACE, isValidCsharpNamespace, } from './efcoreNames.js';
+export const EFCORE_STYLES = ['annotations', 'fluent'];
+/** True when a value is one of the EF Core `--style` values. */
+export function isEfcoreStyle(value) {
+    return EFCORE_STYLES.includes(value);
+}
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+export function emitEfcore(schema, options) {
+    const prepared = options.naming === 'normalize' ? normalizeSchema(schema) : schema;
+    const warnings = prismaOnlyWarnings(prepared, true).filter(isUnhandledWarning);
+    if (options.provider === 'mongodb') {
+        warnings.push('Provider "mongodb": EF Core is relational (use the MongoDB EF Core provider by hand); PostgreSQL column types were written.');
+    }
+    if (prepared.models.length === 0) {
+        return { files: {}, warnings };
+    }
+    const plan = planSchema(prepared, options, warnings);
+    return { files: renderFiles(plan), warnings: dedupe(warnings) };
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}
+/** Drops the Prisma-only notes for things this emitter writes (schemas, views, defaults, composite keys, index details). */
+function isUnhandledWarning(warning) {
+    if (warning.includes('the database default expression')) {
+        return false;
+    }
+    if (warning.includes('(Prisma Unsupported)')) {
+        return false;
+    }
+    if (warning.includes('is generated by Prisma Client and was dropped')) {
+        return false;
+    }
+    if (warning.includes('has no equivalent here; the relation was dropped')) {
+        return false;
+    }
+    if (warning.includes('the index type, clustering, sort order')) {
+        return false;
+    }
+    return !(warning.includes('(@@schema) was ignored') && !warning.startsWith('enum '));
+}
+// ---------------------------------------------------------------------------
+// Planning
+// ---------------------------------------------------------------------------
+const DELETE_BEHAVIORS = {
+    cascade: 'Cascade',
+    setNull: 'SetNull',
+    restrict: 'Restrict',
+    noAction: 'NoAction',
+    setDefault: 'NoAction',
+};
+function planSchema(schema, options, warnings) {
+    const style = options.style ?? 'annotations';
+    const typeNames = new Set(RESERVED_TYPE_NAMES);
+    typeNames.add('AppDbContext');
+    const warn = (message) => {
+        warnings.push(message);
+    };
+    const enums = planEnums(schema, typeNames, warn);
+    const plans = new Map();
+    const dbSets = new Set(DBCONTEXT_MEMBER_NAMES);
+    for (const model of schema.models) {
+        const rawClass = /^[A-Z][A-Za-z0-9]*$/.test(model.name)
+            ? model.name
+            : (pascalIdentifier(model.name) ?? repairedIdentifier(model.name));
+        const reserved = typeNames.has(rawClass);
+        const className = uniqueName(reserved ? `${rawClass}Entity` : rawClass, typeNames);
+        if (className !== rawClass) {
+            warn(`${model.name}: "${rawClass}" is a name the generated code uses or another type has, so the class was named "${className}".`);
+        }
+        const conventional = /^[A-Z][A-Za-z0-9]*$/.test(model.tableName) &&
+            model.tableName !== className &&
+            !dbSets.has(model.tableName);
+        const dbSet = uniqueName(conventional ? model.tableName : pluralize(className), dbSets);
+        plans.set(model.name, {
+            model,
+            className,
+            dbSet,
+            tableName: model.tableName,
+            needsTable: model.tableName !== dbSet,
+            schema: model.schema,
+            used: new Set([className, ...RESERVED_MEMBER_NAMES]),
+            fieldProps: new Map(),
+            relationFks: new Map(),
+            relationNavs: new Map(),
+            columns: [],
+            navs: [],
+            keyProps: [],
+            keyless: false,
+            isView: model.isView === true,
+            keyName: model.primaryKeyName,
+            alternateKeys: [],
+            indexes: [],
+            links: [],
+            manyToMany: [],
+            autoUpdated: [],
+        });
+    }
+    // Property and navigation names ----------------------------------------------------------------
+    for (const model of schema.models) {
+        nameMembers(planOf(plans, model), warn);
+    }
+    const links = [];
+    const manyToMany = [];
+    for (const model of schema.models) {
+        planRelations(schema, plans, planOf(plans, model), links, manyToMany, warn);
+    }
+    for (const link of links) {
+        link.owner.links.push(link);
+    }
+    for (const join of manyToMany) {
+        join.owner.manyToMany.push(join);
+    }
+    // Keys, columns and indexes ----------------------------------------------------------------------
+    const context = { provider: options.provider, enums, warn };
+    for (const model of schema.models) {
+        planAlternateKeys(schema, planOf(plans, model));
+    }
+    for (const model of schema.models) {
+        planColumns(planOf(plans, model), context);
+    }
+    for (const model of schema.models) {
+        planIndexes(planOf(plans, model), options.provider, warn);
+    }
+    return {
+        schema,
+        style,
+        namespace: options.namespace ?? DEFAULT_EFCORE_NAMESPACE,
+        header: options.header !== false,
+        provider: options.provider,
+        models: schema.models.map((model) => planOf(plans, model)),
+        enums: [...enums.values()],
+    };
+}
+function planOf(plans, model) {
+    const plan = plans.get(model.name);
+    if (plan === undefined) {
+        throw new Error(`No plan exists for the model "${model.name}".`);
+    }
+    return plan;
+}
+/** Writes each IR enum as a C# enum and decides how its stored values are mapped. */
+function planEnums(schema, typeNames, warn) {
+    const plans = new Map();
+    for (const enumeration of schema.enums) {
+        const raw = /^[A-Z][A-Za-z0-9]*$/.test(enumeration.name)
+            ? enumeration.name
+            : (pascalIdentifier(enumeration.name) ??
+                repairedIdentifier(enumeration.name));
+        const typeName = uniqueName(typeNames.has(raw) ? `${raw}Enum` : raw, typeNames);
+        if (typeName !== raw) {
+            warn(`enum ${enumeration.name}: "${raw}" is a name the generated code uses or another type has, so the enum was named "${typeName}".`);
+        }
+        const used = new Set();
+        const members = new Map();
+        for (const value of enumeration.values) {
+            const name = uniqueName(repairedIdentifier(value.name), used);
+            if (name !== value.name) {
+                warn(`enum ${enumeration.name}: the member "${value.name}" was written as "${name}".`);
+            }
+            members.set(value.name, name);
+        }
+        const numeric = enumeration.values.length > 0 &&
+            enumeration.values.every((value) => /^-?\d+$/.test(value.dbValue));
+        const namesMatch = enumeration.values.every((value) => members.get(value.name) === value.dbValue);
+        plans.set(enumeration.name, {
+            enumeration,
+            typeName,
+            members,
+            numeric,
+            namesMatch,
+            converterName: () => uniqueName(`${typeName}Converter`, typeNames),
+        });
+    }
+    return plans;
+}
+/** Gives every field and relation of a model its C# names. */
+function nameMembers(plan, warn) {
+    const model = plan.model;
+    for (const field of model.fields) {
+        const base = pascalIdentifier(field.name) ?? repairedIdentifier(field.name);
+        const name = uniqueName(RESERVED_MEMBER_NAMES.has(base) || base === plan.className
+            ? `${base}Value`
+            : base, plan.used);
+        if (name !== base) {
+            warn(`${model.name}.${field.name}: "${base}" cannot be a property of ${plan.className}, so the property was named "${name}".`);
+        }
+        plan.fieldProps.set(field.name, name);
+    }
+    for (const relation of model.relations) {
+        if (relation.kind === 'manyToMany') {
+            continue;
+        }
+        const nav = navigationName(navBase(relation.name, plan), plan.used);
+        plan.relationNavs.set(relation.name, nav);
+        plan.relationFks.set(relation.name, uniqueName(`${nav}Id`, plan.used));
+    }
+    for (const key of model.compositeForeignKeys ?? []) {
+        plan.relationNavs.set(`composite:${key.name}`, navigationName(navBase(key.name, plan), plan.used));
+    }
+    for (const relation of model.relations) {
+        if (relation.kind === 'manyToMany') {
+            plan.relationNavs.set(relation.name, navigationName(navBase(relation.name, plan), plan.used));
+        }
+    }
+}
+function navBase(name, plan) {
+    const base = pascalIdentifier(name) ?? repairedIdentifier(name);
+    return RESERVED_MEMBER_NAMES.has(base) || base === plan.className
+        ? `${base}Ref`
+        : base;
+}
+/** The field a foreign key copies its type from: the referenced column, or the single primary key. */
+function referencedField(schema, target, toField, depth = 0) {
+    if (depth > 5) {
+        return undefined;
+    }
+    const explicit = toField === undefined
+        ? undefined
+        : target.fields.find((field) => field.name === toField || field.columnName === toField);
+    if (explicit !== undefined) {
+        return explicit;
+    }
+    if (target.compositePrimaryKey !== undefined) {
+        const only = target.compositePrimaryKey.length === 1
+            ? target.compositePrimaryKey[0]
+            : undefined;
+        return target.fields.find((field) => field.name === only);
+    }
+    const key = target.fields.find((field) => field.isPrimaryKey);
+    if (key !== undefined) {
+        return key;
+    }
+    const primary = target.relations.find((relation) => relation.isPrimaryKey === true);
+    const chained = primary === undefined ? undefined : findModel(schema, primary.targetModel);
+    return primary === undefined || chained === undefined
+        ? undefined
+        : referencedField(schema, chained, primary.toField, depth + 1);
+}
+/** True when the model has a single-column primary key. */
+function hasSingleKey(model) {
+    if (model.compositePrimaryKey !== undefined) {
+        return model.compositePrimaryKey.length === 1;
+    }
+    return (model.fields.filter((field) => field.isPrimaryKey).length +
+        model.relations.filter((relation) => relation.isPrimaryKey === true).length ===
+        1);
+}
+function planRelations(schema, plans, plan, links, manyToMany, warn) {
+    const model = plan.model;
+    for (const relation of model.relations) {
+        const label = `${model.name}.${relation.name}`;
+        const target = findModel(schema, relation.targetModel);
+        const targetPlan = plans.get(relation.targetModel);
+        if (target === undefined || targetPlan === undefined) {
+            warn(`${label}: the model ${relation.targetModel} is not in the input, so the relation was skipped${relation.kind === 'manyToMany' ? '' : ' and its column left out'}.`);
+            plan.relationFks.delete(relation.name);
+            plan.relationNavs.delete(relation.name);
+            continue;
+        }
+        if (relation.kind === 'manyToMany') {
+            planManyToMany(plan, targetPlan, relation, manyToMany, warn);
+            continue;
+        }
+        const key = referencedField(schema, target, relation.toField);
+        const nav = plan.relationNavs.get(relation.name);
+        const foreignKey = plan.relationFks.get(relation.name);
+        if (key === undefined || nav === undefined || foreignKey === undefined) {
+            warn(`${label}: ${relation.targetModel} has no single-column key to reference, so the relation was skipped and its column left out.`);
+            plan.relationFks.delete(relation.name);
+            plan.relationNavs.delete(relation.name);
+            continue;
+        }
+        const oneToOne = relation.kind === 'oneToOne';
+        const inverse = relation.relatedName === undefined
+            ? undefined
+            : inverseName(targetPlan, relation.relatedName);
+        const behavior = DELETE_BEHAVIORS[relation.onDelete];
+        if (relation.onDelete === 'setDefault') {
+            warn(`${label}: EF Core has no SET DEFAULT delete behavior; NO ACTION was written.`);
+        }
+        const required = !relation.isNullable;
+        if (required && relation.onDelete === 'setNull') {
+            warn(`${label}: SET NULL on a required relation; the column is NOT NULL, so deleting a ${relation.targetModel} that is referenced fails.`);
+        }
+        const isDefault = required
+            ? relation.onDelete === 'cascade'
+            : relation.onDelete === 'noAction';
+        const toKey = relation.toField === undefined
+            ? undefined
+            : target.fields.find((field) => field.name === relation.toField ||
+                field.columnName === relation.toField);
+        links.push({
+            owner: plan,
+            target: targetPlan,
+            relationName: relation.name,
+            relation,
+            nav,
+            inverse,
+            oneToOne,
+            foreignKeys: [foreignKey],
+            principalKeys: toKey !== undefined && !toKey.isPrimaryKey
+                ? [targetPlan.fieldProps.get(toKey.name) ?? toKey.name]
+                : undefined,
+            behavior: isDefault ? undefined : behavior,
+            required,
+            constraintName: relation.constraintName,
+            keyField: key,
+        });
+        if (inverse !== undefined) {
+            targetPlan.navs.push({
+                property: inverse,
+                typeName: plan.className,
+                collection: !oneToOne,
+                nullable: oneToOne,
+                inverseOf: { className: plan.className, property: nav },
+            });
+        }
+    }
+    for (const key of model.compositeForeignKeys ?? []) {
+        planCompositeKey(schema, plans, plan, key, links, warn);
+    }
+}
+function inverseName(target, relatedName) {
+    const base = pascalIdentifier(relatedName) ?? repairedIdentifier(relatedName);
+    const safe = RESERVED_MEMBER_NAMES.has(base) || base === target.className
+        ? `${base}Ref`
+        : base;
+    return navigationName(safe, target.used);
+}
+function planCompositeKey(schema, plans, plan, key, links, warn) {
+    const label = `${plan.model.name}.${key.name}`;
+    const target = findModel(schema, key.targetModel);
+    const targetPlan = plans.get(key.targetModel);
+    const nav = plan.relationNavs.get(`composite:${key.name}`);
+    if (target === undefined || targetPlan === undefined || nav === undefined) {
+        warn(`${label}: the model ${key.targetModel} is not in the input, so the composite foreign key was skipped.`);
+        return;
+    }
+    const localProps = key.fields.map((name) => plan.fieldProps.get(name));
+    const principalProps = key.references.map((name) => targetPlan.fieldProps.get(name));
+    if (localProps.some((name) => name === undefined) ||
+        principalProps.some((name) => name === undefined)) {
+        warn(`${label}: a column of the composite foreign key is not a field of the models, so it was skipped.`);
+        return;
+    }
+    const locals = localProps.filter((name) => name !== undefined);
+    const principals = principalProps.filter((name) => name !== undefined);
+    const oneToOne = key.kind === 'oneToOne';
+    const inverse = key.relatedName === undefined
+        ? undefined
+        : inverseName(targetPlan, key.relatedName);
+    const required = !key.isNullable;
+    if (required && key.onDelete === 'setNull') {
+        warn(`${label}: SET NULL on a required relation; the columns are NOT NULL, so deleting a ${key.targetModel} that is referenced fails.`);
+    }
+    const isPrimary = sameList(key.references, target.compositePrimaryKey ?? []);
+    links.push({
+        owner: plan,
+        target: targetPlan,
+        relationName: key.name,
+        composite: key,
+        nav,
+        inverse,
+        oneToOne,
+        foreignKeys: locals,
+        principalKeys: isPrimary ? undefined : principals,
+        behavior: DELETE_BEHAVIORS[key.onDelete],
+        required,
+        constraintName: key.constraintName,
+        keyField: undefined,
+    });
+    if (key.onDelete === 'setDefault') {
+        warn(`${label}: EF Core has no SET DEFAULT delete behavior; NO ACTION was written.`);
+    }
+    if (key.onUpdate !== undefined) {
+        warn(`${label}: the onUpdate action "${key.onUpdate}" is not supported by this format and was ignored.`);
+    }
+    if (inverse !== undefined) {
+        targetPlan.navs.push({
+            property: inverse,
+            typeName: plan.className,
+            collection: !oneToOne,
+            nullable: oneToOne,
+            inverseOf: { className: plan.className, property: nav },
+        });
+    }
+}
+function sameList(first, second) {
+    return (first.length === second.length &&
+        first.every((value, index) => value === second[index]));
+}
+function planManyToMany(plan, targetPlan, relation, manyToMany, warn) {
+    const label = `${plan.model.name}.${relation.name}`;
+    const nav = plan.relationNavs.get(relation.name);
+    if (nav === undefined ||
+        !hasSingleKey(plan.model) ||
+        !hasSingleKey(targetPlan.model)) {
+        warn(`${label}: a many-to-many relation needs a single-column key on both models; the relation was skipped.`);
+        plan.relationNavs.delete(relation.name);
+        return;
+    }
+    const isSelf = plan.model.name === relation.targetModel;
+    const owner = toSnakeCase(plan.model.name);
+    const other = toSnakeCase(relation.targetModel);
+    const inverse = relation.relatedName === undefined
+        ? undefined
+        : inverseName(targetPlan, relation.relatedName);
+    manyToMany.push({
+        owner: plan,
+        target: targetPlan,
+        relationName: relation.name,
+        nav,
+        inverse,
+        joinTable: `${plan.model.tableName}_${relation.name}`,
+        ownerColumn: `${isSelf ? 'from_' : ''}${owner}_id`,
+        targetColumn: `${isSelf ? 'to_' : ''}${other}_id`,
+    });
+    plan.navs.push({
+        property: nav,
+        typeName: targetPlan.className,
+        collection: true,
+        nullable: false,
+    });
+    if (inverse !== undefined) {
+        targetPlan.navs.push({
+            property: inverse,
+            typeName: plan.className,
+            collection: true,
+            nullable: false,
+        });
+    }
+}
+/** Fields that another model's foreign key points at (`toField`) need an alternate key, not an index. */
+function planAlternateKeys(schema, plan) {
+    const model = plan.model;
+    for (const other of schema.models) {
+        for (const relation of other.relations) {
+            if (relation.targetModel !== model.name ||
+                relation.toField === undefined) {
+                continue;
+            }
+            const field = model.fields.find((candidate) => candidate.name === relation.toField ||
+                candidate.columnName === relation.toField);
+            const property = field === undefined || field.isPrimaryKey
+                ? undefined
+                : plan.fieldProps.get(field.name);
+            if (property !== undefined &&
+                !plan.alternateKeys.some((key) => sameList(key, [property]))) {
+                plan.alternateKeys.push([property]);
+            }
+        }
+    }
+    for (const other of schema.models) {
+        for (const key of other.compositeForeignKeys ?? []) {
+            if (key.targetModel !== model.name) {
+                continue;
+            }
+            if (sameList(key.references, model.compositePrimaryKey ?? [])) {
+                continue;
+            }
+            const properties = key.references
+                .map((name) => plan.fieldProps.get(name))
+                .filter((name) => name !== undefined);
+            if (properties.length === key.references.length &&
+                !plan.alternateKeys.some((existing) => sameList(existing, properties))) {
+                plan.alternateKeys.push(properties);
+            }
+        }
+    }
+}
+/** Builds the columns of a model: its fields, then the foreign key column of every relation. */
+function planColumns(plan, context) {
+    const model = plan.model;
+    const keyNames = model.compositePrimaryKey ?? [
+        ...model.fields
+            .filter((field) => field.isPrimaryKey)
+            .map((field) => field.name),
+        ...model.relations
+            .filter((relation) => relation.isPrimaryKey === true)
+            .map((relation) => relation.name),
+    ];
+    const keyProps = [];
+    for (const name of keyNames) {
+        const property = plan.fieldProps.get(name) ?? plan.relationFks.get(name);
+        if (property === undefined) {
+            context.warn(`${model.name}: the primary key member "${name}" is not a field or relation of the model and was left out of the key.`);
+        }
+        else {
+            keyProps.push(property);
+        }
+    }
+    plan.keyProps = keyProps;
+    const singleKey = keyProps.length === 1;
+    plan.keyless = keyProps.length === 0;
+    if (plan.keyless && !plan.isView) {
+        context.warn(`${model.name}: the model has no primary key; EF Core needs a key, so the class was written as keyless ([Keyless]).`);
+        // EF Core maps a keyless entity to no table unless the table is named explicitly.
+        plan.needsTable = true;
+    }
+    const columns = [];
+    for (const field of model.fields) {
+        const property = plan.fieldProps.get(field.name) ?? field.name;
+        const isKey = keyProps.includes(property);
+        const spec = buildColumn(context, `${model.name}.${field.name}`, isKey && keyProps.length > 1 ? { ...field, isUnique: false } : field, { propertyName: property, isKey, singleKey });
+        columns.push({ property, spec, isKey, fieldName: field.name });
+        if (spec.autoUpdated) {
+            plan.autoUpdated.push(property);
+        }
+    }
+    for (const link of plan.links) {
+        if (link.relation === undefined) {
+            continue;
+        }
+        const relation = link.relation;
+        const key = link.keyField;
+        const property = link.foreignKeys[0];
+        if (key === undefined || property === undefined) {
+            continue;
+        }
+        const isKey = keyProps.includes(property);
+        // The column copies the type of the key it references, without the key's own default or flags.
+        const column = {
+            name: relation.name,
+            columnName: relation.columnName,
+            type: key.type,
+            isPrimaryKey: false,
+            isUnique: false,
+            isNullable: relation.isNullable,
+            isAutoUpdated: false,
+            ...(key.maxLength === undefined ? {} : { maxLength: key.maxLength }),
+            ...(key.maxDigits === undefined ? {} : { maxDigits: key.maxDigits }),
+            ...(key.decimalPlaces === undefined
+                ? {}
+                : { decimalPlaces: key.decimalPlaces }),
+            ...(key.enumName === undefined ? {} : { enumName: key.enumName }),
+        };
+        const spec = buildColumn(context, `${model.name}.${relation.name}`, column, { propertyName: property, isKey, singleKey });
+        columns.push({ property, spec, isKey, relationName: relation.name });
+    }
+    plan.columns = columns;
+    // Navigations in declaration order: the references of this model, then its collections.
+    const references = plan.links.map((link) => {
+        const target = link.target;
+        return {
+            property: link.nav,
+            typeName: target.className,
+            collection: false,
+            nullable: !link.required,
+            foreignKeys: link.foreignKeys,
+            ...(link.inverse === undefined
+                ? {}
+                : {
+                    inverseOf: { className: target.className, property: link.inverse },
+                }),
+        };
+    });
+    plan.navs = [...references, ...plan.navs];
+}
+/** Collects the indexes of a model: unique fields, one-to-one keys and the declared indexes. */
+function planIndexes(plan, provider, warn) {
+    const model = plan.model;
+    const indexes = [];
+    const seen = new Set();
+    const alternate = new Set(plan.alternateKeys.map((key) => key.join(',')));
+    const add = (index) => {
+        const signature = `${index.unique ? 'u' : 'i'}|${index.properties.join(',')}|${index.name ?? ''}`;
+        if (seen.has(signature)) {
+            return;
+        }
+        seen.add(signature);
+        indexes.push(index);
+    };
+    const isKey = (properties) => sameList(properties, plan.keyProps);
+    const covered = (properties) => indexes.some((index) => index.unique && sameList(index.properties, properties));
+    for (const field of model.fields) {
+        const property = plan.fieldProps.get(field.name);
+        if (property === undefined ||
+            !field.isUnique ||
+            field.isPrimaryKey ||
+            isKey([property])) {
+            continue;
+        }
+        if (alternate.has(property)) {
+            continue;
+        }
+        add({
+            properties: [property],
+            unique: true,
+            descending: [],
+            ...(field.uniqueName === undefined ? {} : { name: field.uniqueName }),
+        });
+    }
+    for (const link of plan.links) {
+        if (link.relation?.kind === 'oneToOne' &&
+            link.relation.isPrimaryKey !== true &&
+            !covered(link.foreignKeys)) {
+            add({
+                properties: link.foreignKeys,
+                unique: true,
+                descending: [],
+            });
+        }
+    }
+    for (const index of model.indexes) {
+        const properties = [];
+        let skip = false;
+        for (const name of index.fields) {
+            const property = plan.fieldProps.get(name) ?? plan.relationFks.get(name);
+            if (property === undefined) {
+                warn(`${model.name}: the index (${index.fields.join(', ')}) refers to "${name}", which is not a field or relation of the model; the index was skipped.`);
+                skip = true;
+                break;
+            }
+            properties.push(property);
+        }
+        if (skip) {
+            continue;
+        }
+        if (index.isUnique &&
+            index.name === undefined &&
+            alternate.has(properties.join(','))) {
+            continue;
+        }
+        add(indexOf(model, index, properties, provider, warn));
+    }
+    plan.indexes = indexes;
+}
+function indexOf(model, index, properties, provider, warn) {
+    const label = `${model.name} index (${index.fields.join(', ')})`;
+    const descending = index.fields.map((name) => index.fieldOptions?.[name]?.sort === 'desc');
+    let method;
+    if (index.method !== undefined) {
+        if (isPostgres(provider)) {
+            method = index.method.toLowerCase();
+        }
+        else {
+            warn(`${label}: the ${index.method} index method only exists in PostgreSQL (Npgsql); it was dropped.`);
+        }
+    }
+    const unsupported = [];
+    for (const options of Object.values(index.fieldOptions ?? {})) {
+        if (options.length !== undefined) {
+            unsupported.push('prefix length');
+        }
+        if (options.ops !== undefined) {
+            unsupported.push('operator class');
+        }
+    }
+    if (index.clustered !== undefined) {
+        unsupported.push('clustering');
+    }
+    if (unsupported.length > 0) {
+        warn(`${label}: the ${[...new Set(unsupported)].join(' and ')} option has no EF Core equivalent and was dropped.`);
+    }
+    return {
+        properties,
+        unique: index.isUnique,
+        descending: descending.some((flag) => flag) ? descending : [],
+        ...(index.name === undefined ? {} : { name: index.name }),
+        ...(method === undefined ? {} : { method }),
+    };
+}
+//# sourceMappingURL=efcore.js.map