ormbridge 0.0.0-stage → 0.3.0

package/dist/parsers/prisma.js

@@ -0,0 +1,964 @@
+import { err, ok } from '../result.js';
+/** Postgres range types that Prisma can only express as Unsupported("..."), mapped to the IR range subtype. */
+const RANGE_TYPES = {
+    int4range: 'int',
+    int8range: 'bigInt',
+    numrange: 'decimal',
+    daterange: 'date',
+    tstzrange: 'dateTime',
+    tsrange: 'dateTime',
+};
+/** Native types whose single argument is a character length rather than a bit or byte count. */
+const LENGTH_TYPES = new Set([
+    'VarChar',
+    'Char',
+    'NVarChar',
+    'NChar',
+    'String',
+]);
+const TEXT_TYPES = new Set([
+    'Text',
+    'TinyText',
+    'MediumText',
+    'LongText',
+    'NText',
+]);
+const SCALAR_TYPES = new Set([
+    'String',
+    'Int',
+    'BigInt',
+    'Float',
+    'Decimal',
+    'Boolean',
+    'DateTime',
+    'Json',
+    'Bytes',
+]);
+const ON_DELETE_VALUES = {
+    Cascade: 'cascade',
+    SetNull: 'setNull',
+    Restrict: 'restrict',
+    NoAction: 'noAction',
+    SetDefault: 'setDefault',
+};
+/** Parses a Prisma schema (hand-written tokenizer, no Prisma engine required) into the shared IR. */
+export function parsePrisma(sources, options) {
+    const warnings = [];
+    const combinedText = sources
+        .map((source) => source.text)
+        .join('\n');
+    const strippedText = stripComments(combinedText);
+    const { models, enums, provider } = readBlocks(strippedText, warnings);
+    if (models.length === 0) {
+        const checkedPaths = sources
+            .map((source) => source.path)
+            .join(', ');
+        return err('NO_MODELS_FOUND', `No "model" blocks were found in: ${checkedPaths}.`);
+    }
+    const enumNames = new Set(enums.map((enumDefinition) => enumDefinition.name));
+    const modelByName = new Map(models.map((model) => [model.name, model]));
+    const manyToManyOwners = findManyToMany(models, modelByName);
+    const irModels = models.map((model) => buildModel(model, modelByName, enumNames, enums, manyToManyOwners, provider, options, warnings));
+    return ok({ models: irModels, enums, warnings });
+}
+// ---------------------------------------------------------------------------
+// Tokenizing
+// ---------------------------------------------------------------------------
+function stripComments(text) {
+    let result = '';
+    let inString = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index] ?? '';
+        const next = text[index + 1] ?? '';
+        if (inString) {
+            result += character;
+            if (character === '\\') {
+                result += next;
+                index += 1;
+            }
+            else if (character === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+            result += character;
+        }
+        else if (character === '/' && next === '/') {
+            while (index < text.length && text[index] !== '\n') {
+                index += 1;
+            }
+            result += '\n';
+        }
+        else {
+            result += character;
+        }
+    }
+    return result;
+}
+function readBlocks(text, warnings) {
+    const models = [];
+    const enums = [];
+    let provider;
+    const lines = text.split('\n');
+    const blockStart = /^\s*(model|enum|type|view|generator|datasource)\s+(\w+)\s*\{\s*(.*)$/;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        const match = blockStart.exec(lines[lineIndex] ?? '');
+        if (match === null) {
+            continue;
+        }
+        const kind = match[1] ?? '';
+        const name = match[2] ?? '';
+        const body = [];
+        const remainder = (match[3] ?? '').trim();
+        let closed = false;
+        if (remainder.endsWith('}')) {
+            const inner = remainder.slice(0, -1).trim();
+            if (inner.length > 0) {
+                body.push(inner);
+            }
+            closed = true;
+        }
+        else if (remainder.length > 0) {
+            body.push(remainder);
+        }
+        while (!closed && lineIndex + 1 < lines.length) {
+            lineIndex += 1;
+            const bodyLine = (lines[lineIndex] ?? '').trim();
+            if (bodyLine === '}') {
+                closed = true;
+                break;
+            }
+            if (bodyLine.length > 0) {
+                body.push(bodyLine);
+            }
+        }
+        if (!closed) {
+            warnings.push(`The ${kind} block "${name}" is missing its closing brace; parsing continued with what was found.`);
+        }
+        if (kind === 'datasource') {
+            for (const bodyLine of body) {
+                const providerMatch = /^provider\s*=\s*"([^"]*)"/.exec(bodyLine);
+                if (providerMatch !== null) {
+                    provider = providerMatch[1];
+                }
+            }
+        }
+        else if (kind === 'model' || kind === 'view') {
+            models.push(parseModelBlock(name, body, kind === 'view', warnings));
+        }
+        else if (kind === 'enum') {
+            enums.push(parseEnumBlock(name, body, warnings));
+        }
+        else if (kind === 'type') {
+            warnings.push(`The composite type "${name}" is not supported and was skipped; fields that use it are skipped too.`);
+        }
+    }
+    return { models, enums, provider };
+}
+function parseEnumBlock(name, body, warnings) {
+    const values = [];
+    let dbName;
+    let schemaName;
+    for (const line of body) {
+        if (line.startsWith('@@')) {
+            for (const attribute of parseAttributes(line)) {
+                if (attribute.name === 'map') {
+                    dbName = firstStringArgument(attribute);
+                }
+                else if (attribute.name === 'schema') {
+                    schemaName = firstStringArgument(attribute);
+                }
+                else {
+                    warnings.push(`enum ${name}: @@${attribute.name} is not supported and was ignored.`);
+                }
+            }
+            continue;
+        }
+        const memberMatch = /^(\w+)\s*(.*)$/.exec(line);
+        if (memberMatch === null) {
+            continue;
+        }
+        const memberName = memberMatch[1] ?? '';
+        const mapAttribute = parseAttributes(memberMatch[2] ?? '').find((attribute) => attribute.name === 'map');
+        const mappedValue = mapAttribute === undefined
+            ? undefined
+            : firstStringArgument(mapAttribute);
+        values.push({ name: memberName, dbValue: mappedValue ?? memberName });
+    }
+    return {
+        name,
+        values,
+        ...(dbName === undefined ? {} : { dbName }),
+        ...(schemaName === undefined ? {} : { schema: schemaName }),
+    };
+}
+function parseModelBlock(name, body, isView, warnings) {
+    const fields = [];
+    const blockAttributes = [];
+    for (const line of body) {
+        if (line.startsWith('@@')) {
+            blockAttributes.push(...parseAttributes(line));
+            continue;
+        }
+        const fieldMatch = /^(\w+)\s+(Unsupported\(\s*"(?:[^"\\]|\\.)*"\s*\)|\w+)(\[\])?(\?)?\s*(.*)$/.exec(line);
+        if (fieldMatch === null) {
+            warnings.push(`${isView ? 'View' : 'Model'} ${name}: the line "${line}" could not be understood and was skipped.`);
+            continue;
+        }
+        const rawType = fieldMatch[2] ?? '';
+        const isUnsupported = rawType.startsWith('Unsupported(');
+        const unsupportedText = rawType.slice(rawType.indexOf('(') + 1, rawType.lastIndexOf(')'));
+        fields.push({
+            name: fieldMatch[1] ?? '',
+            typeName: isUnsupported ? 'Unsupported' : rawType,
+            isList: fieldMatch[3] !== undefined,
+            isOptional: fieldMatch[4] !== undefined,
+            attributes: parseAttributes(fieldMatch[5] ?? ''),
+            ...(isUnsupported ? { unsupportedType: unquote(unsupportedText) } : {}),
+        });
+    }
+    return { name, fields, blockAttributes, isView };
+}
+function findClosingParenthesis(text, openIndex) {
+    let depth = 0;
+    let inString = false;
+    for (let index = openIndex; index < text.length; index += 1) {
+        const character = text[index] ?? '';
+        if (inString) {
+            if (character === '\\') {
+                index += 1;
+            }
+            else if (character === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+        }
+        else if (character === '(') {
+            depth += 1;
+        }
+        else if (character === ')') {
+            depth -= 1;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return text.length;
+}
+function parseAttributes(text) {
+    const attributes = [];
+    let index = 0;
+    while (index < text.length) {
+        const atIndex = text.indexOf('@', index);
+        if (atIndex === -1) {
+            break;
+        }
+        let cursor = atIndex + 1;
+        if (text[cursor] === '@') {
+            cursor += 1;
+        }
+        const nameStart = cursor;
+        while (cursor < text.length && /[\w.]/.test(text[cursor] ?? '')) {
+            cursor += 1;
+        }
+        const name = text.slice(nameStart, cursor);
+        let args;
+        if (text[cursor] === '(') {
+            const closeIndex = findClosingParenthesis(text, cursor);
+            args = text.slice(cursor + 1, closeIndex);
+            cursor = closeIndex + 1;
+        }
+        attributes.push({ name, args });
+        index = Math.max(cursor, atIndex + 1);
+    }
+    return attributes;
+}
+function splitTopLevel(text) {
+    const parts = [];
+    let depth = 0;
+    let inString = false;
+    let current = '';
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index] ?? '';
+        if (inString) {
+            current += character;
+            if (character === '\\') {
+                current += text[index + 1] ?? '';
+                index += 1;
+            }
+            else if (character === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+            current += character;
+        }
+        else if (character === '(' || character === '[' || character === '{') {
+            depth += 1;
+            current += character;
+        }
+        else if (character === ')' || character === ']' || character === '}') {
+            depth -= 1;
+            current += character;
+        }
+        else if (character === ',' && depth === 0) {
+            parts.push(current.trim());
+            current = '';
+        }
+        else {
+            current += character;
+        }
+    }
+    if (current.trim().length > 0) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed === 'string') {
+                return parsed;
+            }
+        }
+        catch {
+            return trimmed.slice(1, -1);
+        }
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+/** Returns the argument supplied under a keyword (e.g. fields: [a, b]) as raw text. */
+function namedArgument(attribute, key) {
+    if (attribute === undefined || attribute.args === undefined) {
+        return undefined;
+    }
+    for (const part of splitTopLevel(attribute.args)) {
+        const match = /^(\w+)\s*:\s*([\s\S]*)$/.exec(part);
+        if (match !== null && match[1] === key) {
+            return (match[2] ?? '').trim();
+        }
+    }
+    return undefined;
+}
+/** Returns the first argument when it is positional (not key: value). */
+function positionalArgument(attribute) {
+    if (attribute === undefined || attribute.args === undefined) {
+        return undefined;
+    }
+    const first = splitTopLevel(attribute.args)[0];
+    if (first === undefined || /^\w+\s*:/.test(first)) {
+        return undefined;
+    }
+    return first;
+}
+function firstStringArgument(attribute) {
+    const positional = positionalArgument(attribute);
+    return positional === undefined ? undefined : unquote(positional);
+}
+function parseNameList(rawList) {
+    if (rawList === undefined) {
+        return [];
+    }
+    const inner = rawList.trim().replace(/^\[/, '').replace(/\]$/, '');
+    return splitTopLevel(inner).map((item) => item.replace(/\(.*\)$/, '').trim());
+}
+function attributeNamed(attributes, name) {
+    return attributes.find((attribute) => attribute.name === name);
+}
+/** Name given to a relation through @relation("Name") or @relation(name: "Name"). */
+function relationLabel(field) {
+    const relationAttribute = attributeNamed(field.attributes, 'relation');
+    if (relationAttribute === undefined) {
+        return undefined;
+    }
+    const named = namedArgument(relationAttribute, 'name');
+    if (named !== undefined) {
+        return unquote(named);
+    }
+    const positional = positionalArgument(relationAttribute);
+    return positional === undefined ? undefined : unquote(positional);
+}
+function ownsForeignKey(field) {
+    const relationAttribute = attributeNamed(field.attributes, 'relation');
+    return namedArgument(relationAttribute, 'fields') !== undefined;
+}
+// ---------------------------------------------------------------------------
+// Relations
+// ---------------------------------------------------------------------------
+/**
+ * Finds implicit many-to-many pairs (a list field on both models, neither owning a foreign key).
+ * Returns, per owning model, the list fields that should become ManyToManyField definitions.
+ */
+function findManyToMany(models, modelByName) {
+    const owners = new Map();
+    for (const model of models) {
+        for (const field of model.fields) {
+            if (!field.isList ||
+                !modelByName.has(field.typeName) ||
+                ownsForeignKey(field)) {
+                continue;
+            }
+            const target = modelByName.get(field.typeName);
+            const counterpart = target?.fields.find((candidate) => candidate !== field &&
+                candidate.isList &&
+                candidate.typeName === model.name &&
+                !ownsForeignKey(candidate) &&
+                relationLabel(candidate) === relationLabel(field));
+            if (counterpart === undefined || target === undefined) {
+                continue;
+            }
+            const isOwner = `${model.name}.${field.name}` < `${target.name}.${counterpart.name}`;
+            if (isOwner) {
+                const ownerFields = owners.get(model.name) ?? new Map();
+                ownerFields.set(field.name, counterpart);
+                owners.set(model.name, ownerFields);
+            }
+        }
+    }
+    return owners;
+}
+function findInverseField(owner, field, target) {
+    const label = relationLabel(field);
+    return target.fields.find((candidate) => candidate.typeName === owner.name &&
+        !ownsForeignKey(candidate) &&
+        relationLabel(candidate) === label);
+}
+/** Reads `[a, b(sort: Desc, length: 10)]` into field names plus per-field options. */
+function parseIndexEntries(location, rawList, warnings) {
+    if (rawList === undefined) {
+        return [];
+    }
+    const inner = rawList.trim().replace(/^\[/, '').replace(/\]$/, '');
+    const entries = [];
+    for (const item of splitTopLevel(inner)) {
+        const match = /^(\w+)\s*(?:\(([\s\S]*)\))?$/.exec(item);
+        if (match === null) {
+            warnings.push(`${location}: the index entry "${item}" could not be understood and was skipped.`);
+            continue;
+        }
+        const entryName = match[1] ?? '';
+        const options = {};
+        for (const part of splitTopLevel(match[2] ?? '')) {
+            const optionMatch = /^(\w+)\s*:\s*([\s\S]*)$/.exec(part);
+            const key = optionMatch?.[1] ?? '';
+            const value = (optionMatch?.[2] ?? '').trim();
+            if (key === 'sort' && (value === 'Asc' || value === 'Desc')) {
+                options.sort = value === 'Asc' ? 'asc' : 'desc';
+            }
+            else if (key === 'length' && /^\d+$/.test(value)) {
+                options.length = Number(value);
+            }
+            else if (key === 'ops' && value.length > 0) {
+                options.ops = value;
+            }
+            else {
+                warnings.push(`${location}: the option "${part}" on index entry "${entryName}" is not supported and was dropped.`);
+            }
+        }
+        entries.push({ name: entryName, options });
+    }
+    return entries;
+}
+function booleanArgument(attribute, key) {
+    const raw = namedArgument(attribute, key);
+    if (raw === 'true') {
+        return true;
+    }
+    return raw === 'false' ? false : undefined;
+}
+function buildModel(model, modelByName, enumNames, enums, manyToManyOwners, provider, options, warnings) {
+    const consumedScalars = new Map();
+    const relations = [];
+    const compositeForeignKeys = [];
+    for (const field of model.fields) {
+        if (!modelByName.has(field.typeName)) {
+            continue;
+        }
+        const target = modelByName.get(field.typeName);
+        if (target === undefined) {
+            continue;
+        }
+        if (field.isList) {
+            const counterpart = manyToManyOwners
+                .get(model.name)
+                ?.get(field.name);
+            if (counterpart !== undefined) {
+                relations.push({
+                    name: field.name,
+                    kind: 'manyToMany',
+                    targetModel: target.name,
+                    columnName: '',
+                    isNullable: false,
+                    onDelete: 'cascade',
+                    relatedName: counterpart.name,
+                });
+                warnings.push(`${model.name}.${field.name}: Prisma's implicit many-to-many table ("_${model.name}To${target.name}" with columns A and B) ` +
+                    `differs from the join table Django will create; migrate data or define an explicit through model.`);
+            }
+            continue;
+        }
+        if (!ownsForeignKey(field)) {
+            continue;
+        }
+        const keyColumns = parseNameList(namedArgument(attributeNamed(field.attributes, 'relation'), 'fields'));
+        if (keyColumns.length > 1) {
+            const compositeKey = buildCompositeForeignKey(model, field, target, keyColumns, warnings);
+            if (compositeKey !== undefined) {
+                compositeForeignKeys.push(compositeKey);
+            }
+            continue;
+        }
+        const relation = buildForeignKey(model, field, target, consumedScalars, warnings);
+        if (relation !== undefined) {
+            relations.push(relation);
+        }
+    }
+    const fields = [];
+    for (const field of model.fields) {
+        if (modelByName.has(field.typeName) || consumedScalars.has(field.name)) {
+            continue;
+        }
+        const scalarField = buildScalarField(model, field, enumNames, enums, provider, warnings);
+        if (scalarField !== undefined) {
+            fields.push(scalarField);
+        }
+    }
+    const resolveName = (name) => consumedScalars.get(name) ?? name;
+    const indexes = [];
+    let compositePrimaryKey;
+    let primaryKeyName;
+    let isIgnored = false;
+    let schemaName;
+    for (const attribute of model.blockAttributes) {
+        const location = `${model.name} @@${attribute.name}`;
+        const rawFields = positionalArgument(attribute) ?? namedArgument(attribute, 'fields');
+        if (attribute.name === 'id') {
+            const entries = parseIndexEntries(location, rawFields, warnings);
+            compositePrimaryKey = entries.map((entry) => resolveName(entry.name));
+            if (entries.some((entry) => Object.keys(entry.options).length > 0)) {
+                warnings.push(`${location}: sort and length options on primary key fields are not kept.`);
+            }
+            const mapArgument = namedArgument(attribute, 'map');
+            if (mapArgument !== undefined) {
+                primaryKeyName = unquote(mapArgument);
+            }
+            if (namedArgument(attribute, 'name') !== undefined) {
+                warnings.push(`${location}: the client-side key name (name: ...) is not kept; Prisma Client will use the default compound key name.`);
+            }
+        }
+        else if (attribute.name === 'unique' ||
+            attribute.name === 'index' ||
+            attribute.name === 'fulltext') {
+            const entries = parseIndexEntries(location, rawFields, warnings).map((entry) => ({
+                ...entry,
+                name: resolveName(entry.name),
+            }));
+            if (entries.length === 0) {
+                continue;
+            }
+            indexes.push(buildIndex(location, attribute, entries, warnings));
+        }
+        else if (attribute.name === 'ignore') {
+            isIgnored = true;
+        }
+        else if (attribute.name === 'schema') {
+            schemaName = firstStringArgument(attribute);
+        }
+        else if (attribute.name !== 'map') {
+            warnings.push(`${location} is not supported and was ignored.`);
+        }
+    }
+    for (const field of model.fields) {
+        const idAttribute = attributeNamed(field.attributes, 'id');
+        const idMap = namedArgument(idAttribute, 'map');
+        if (idMap !== undefined) {
+            primaryKeyName = unquote(idMap);
+        }
+    }
+    const mapAttribute = attributeNamed(model.blockAttributes, 'map');
+    const tableName = (mapAttribute === undefined
+        ? undefined
+        : firstStringArgument(mapAttribute)) ?? model.name;
+    return {
+        name: model.name,
+        tableName,
+        appLabel: options.appLabel,
+        fields,
+        relations,
+        indexes,
+        ...(compositePrimaryKey === undefined ? {} : { compositePrimaryKey }),
+        ...(model.isView ? { isView: true } : {}),
+        ...(isIgnored ? { isIgnored: true } : {}),
+        ...(schemaName === undefined ? {} : { schema: schemaName }),
+        ...(primaryKeyName === undefined ? {} : { primaryKeyName }),
+        ...(compositeForeignKeys.length === 0 ? {} : { compositeForeignKeys }),
+    };
+}
+function buildIndex(location, attribute, entries, warnings) {
+    const mapArgument = namedArgument(attribute, 'map');
+    const typeArgument = namedArgument(attribute, 'type');
+    const fieldOptions = {};
+    for (const entry of entries) {
+        if (Object.keys(entry.options).length > 0) {
+            fieldOptions[entry.name] = entry.options;
+        }
+    }
+    const clustered = booleanArgument(attribute, 'clustered');
+    if (attribute.name === 'unique' &&
+        namedArgument(attribute, 'name') !== undefined) {
+        warnings.push(`${location}: the client-side key name (name: ...) is not kept; Prisma Client will use the default compound key name.`);
+    }
+    if (namedArgument(attribute, 'where') !== undefined) {
+        warnings.push(`${location}: the partial index condition (where: ...) is not supported and was dropped.`);
+    }
+    return {
+        fields: entries.map((entry) => entry.name),
+        isUnique: attribute.name === 'unique',
+        ...(mapArgument === undefined ? {} : { name: unquote(mapArgument) }),
+        ...(attribute.name === 'fulltext' ? { kind: 'fulltext' } : {}),
+        ...(typeArgument === undefined ? {} : { method: typeArgument }),
+        ...(clustered === undefined ? {} : { clustered }),
+        ...(Object.keys(fieldOptions).length === 0 ? {} : { fieldOptions }),
+    };
+}
+function scalarColumnName(field) {
+    const mapAttribute = attributeNamed(field.attributes, 'map');
+    return ((mapAttribute === undefined
+        ? undefined
+        : firstStringArgument(mapAttribute)) ?? field.name);
+}
+function referentialAction(relationAttribute, key) {
+    const raw = namedArgument(relationAttribute, key);
+    return raw === undefined ? undefined : ON_DELETE_VALUES[raw];
+}
+/** True when the listed scalar fields are exactly a unique constraint or the primary key. */
+function isUniqueSet(model, names) {
+    const wanted = [...names].sort().join();
+    const sameSet = (candidate) => [...candidate].sort().join() === wanted;
+    if (names.length === 1) {
+        const only = model.fields.find((candidate) => candidate.name === names[0]);
+        if (only !== undefined &&
+            (attributeNamed(only.attributes, 'id') !== undefined ||
+                attributeNamed(only.attributes, 'unique') !== undefined)) {
+            return true;
+        }
+    }
+    return model.blockAttributes.some((attribute) => (attribute.name === 'unique' || attribute.name === 'id') &&
+        sameSet(parseNameList(positionalArgument(attribute) ?? namedArgument(attribute, 'fields'))));
+}
+function buildCompositeForeignKey(model, field, target, keyColumns, warnings) {
+    const relationAttribute = attributeNamed(field.attributes, 'relation');
+    const references = parseNameList(namedArgument(relationAttribute, 'references'));
+    const location = `${model.name}.${field.name}`;
+    if (references.length !== keyColumns.length) {
+        warnings.push(`${location}: the composite foreign key lists ${keyColumns.length} fields but ${references.length} references; the relation was skipped.`);
+        return undefined;
+    }
+    const missingLocal = keyColumns.find((name) => !model.fields.some((candidate) => candidate.name === name));
+    if (missingLocal !== undefined) {
+        warnings.push(`${location}: the foreign key field "${missingLocal}" does not exist on ${model.name}; the relation was skipped.`);
+        return undefined;
+    }
+    const missingTarget = references.find((name) => !target.fields.some((candidate) => candidate.name === name));
+    if (missingTarget !== undefined) {
+        warnings.push(`${location}: the referenced field "${missingTarget}" does not exist on ${target.name}; the relation was skipped.`);
+        return undefined;
+    }
+    const onDelete = referentialAction(relationAttribute, 'onDelete') ??
+        (field.isOptional ? 'setNull' : 'restrict');
+    const onUpdate = referentialAction(relationAttribute, 'onUpdate');
+    const constraint = namedArgument(relationAttribute, 'map');
+    const inverse = findInverseField(model, field, target);
+    return {
+        name: field.name,
+        targetModel: target.name,
+        fields: keyColumns,
+        references,
+        kind: isUniqueSet(model, keyColumns) ? 'oneToOne' : 'foreignKey',
+        isNullable: field.isOptional,
+        onDelete,
+        ...(onUpdate === undefined ? {} : { onUpdate }),
+        ...(inverse === undefined ? {} : { relatedName: inverse.name }),
+        ...(constraint === undefined
+            ? {}
+            : { constraintName: unquote(constraint) }),
+    };
+}
+function buildForeignKey(model, field, target, consumedScalars, warnings) {
+    const relationAttribute = attributeNamed(field.attributes, 'relation');
+    const foreignKeyNames = parseNameList(namedArgument(relationAttribute, 'fields'));
+    const referenceNames = parseNameList(namedArgument(relationAttribute, 'references'));
+    const location = `${model.name}.${field.name}`;
+    const scalarName = foreignKeyNames[0] ?? '';
+    const scalarField = model.fields.find((candidate) => candidate.name === scalarName);
+    if (scalarField === undefined) {
+        warnings.push(`${location}: the foreign key field "${scalarName}" does not exist on ${model.name}; the relation was skipped.`);
+        return undefined;
+    }
+    consumedScalars.set(scalarName, field.name);
+    const isPrimaryKey = attributeNamed(scalarField.attributes, 'id') !== undefined;
+    const isUnique = isUniqueSet(model, [scalarName]);
+    const onDelete = referentialAction(relationAttribute, 'onDelete') ??
+        (field.isOptional ? 'setNull' : 'restrict');
+    const onUpdate = referentialAction(relationAttribute, 'onUpdate');
+    const constraint = namedArgument(relationAttribute, 'map');
+    const inverse = findInverseField(model, field, target);
+    const referencedField = referenceNames[0];
+    const targetKeyField = target.fields.find((candidate) => attributeNamed(candidate.attributes, 'id') !== undefined);
+    const needsToField = referencedField !== undefined &&
+        (targetKeyField === undefined || referencedField !== targetKeyField.name);
+    return {
+        name: field.name,
+        kind: isPrimaryKey || isUnique ? 'oneToOne' : 'foreignKey',
+        targetModel: target.name,
+        columnName: scalarColumnName(scalarField),
+        isNullable: field.isOptional,
+        onDelete,
+        ...(onUpdate === undefined ? {} : { onUpdate }),
+        ...(inverse === undefined ? {} : { relatedName: inverse.name }),
+        ...(needsToField && referencedField !== undefined
+            ? { toField: referencedField }
+            : {}),
+        ...(isPrimaryKey ? { isPrimaryKey: true } : {}),
+        ...(constraint === undefined
+            ? {}
+            : { constraintName: unquote(constraint) }),
+    };
+}
+function numericArgument(value) {
+    return value !== undefined && /^\d+$/.test(value) ? Number(value) : undefined;
+}
+/** Prisma's default Decimal precision and scale when no @db.Decimal(p, s) is given. */
+function defaultDecimal(provider) {
+    return provider === 'sqlserver' ? [32, 16] : [65, 30];
+}
+function buildScalarField(model, field, enumNames, enums, provider, warnings) {
+    const location = `${model.name}.${field.name}`;
+    const isEnum = enumNames.has(field.typeName);
+    const isUnsupported = field.typeName === 'Unsupported';
+    if (!isUnsupported && !isEnum && !SCALAR_TYPES.has(field.typeName)) {
+        warnings.push(`${location}: the type "${field.typeName}" is not a known scalar, enum or model; the field was skipped.`);
+        return undefined;
+    }
+    const nativeAttribute = field.attributes.find((attribute) => attribute.name.startsWith('db.'));
+    const nativeName = nativeAttribute === undefined ? '' : nativeAttribute.name.slice(3);
+    const nativeArguments = nativeAttribute?.args === undefined
+        ? []
+        : splitTopLevel(nativeAttribute.args);
+    let type;
+    let maxLength;
+    let maxDigits;
+    let decimalPlaces;
+    let rangeOf;
+    let unsupportedType;
+    if (isUnsupported) {
+        const rawType = field.unsupportedType ?? '';
+        const rangeSubtype = field.isList
+            ? undefined
+            : RANGE_TYPES[rawType.toLowerCase()];
+        if (rangeSubtype !== undefined) {
+            type = 'range';
+            rangeOf = rangeSubtype;
+        }
+        else {
+            type = 'unsupported';
+            unsupportedType = rawType;
+        }
+    }
+    else if (isEnum) {
+        type = 'string';
+    }
+    else {
+        switch (field.typeName) {
+            case 'String':
+                if (TEXT_TYPES.has(nativeName)) {
+                    type = 'text';
+                }
+                else if (nativeName === 'Uuid' || nativeName === 'UniqueIdentifier') {
+                    type = 'uuid';
+                }
+                else if (nativeName === 'Inet') {
+                    type = 'ipAddress';
+                }
+                else {
+                    type = 'string';
+                    if (LENGTH_TYPES.has(nativeName)) {
+                        maxLength = numericArgument(nativeArguments[0]);
+                    }
+                }
+                break;
+            case 'Int':
+                type = 'int';
+                break;
+            case 'BigInt':
+                type = 'bigInt';
+                break;
+            case 'Float':
+                type = 'float';
+                break;
+            case 'Decimal': {
+                type = 'decimal';
+                if (nativeName !== 'Money' && nativeName !== 'SmallMoney') {
+                    const [defaultDigits, defaultPlaces] = defaultDecimal(provider);
+                    maxDigits = numericArgument(nativeArguments[0]) ?? defaultDigits;
+                    decimalPlaces = numericArgument(nativeArguments[1]) ?? defaultPlaces;
+                }
+                break;
+            }
+            case 'Boolean':
+                type = 'boolean';
+                break;
+            case 'DateTime':
+                type =
+                    nativeName === 'Date'
+                        ? 'date'
+                        : nativeName.startsWith('Time') &&
+                            !nativeName.startsWith('Timestamp')
+                            ? 'time'
+                            : 'dateTime';
+                break;
+            case 'Json':
+                type = 'json';
+                break;
+            case 'Bytes':
+                type = 'bytes';
+                break;
+            default:
+                type = 'string';
+        }
+    }
+    const irField = {
+        name: field.name,
+        columnName: scalarColumnName(field),
+        type,
+        isPrimaryKey: attributeNamed(field.attributes, 'id') !== undefined,
+        isUnique: attributeNamed(field.attributes, 'unique') !== undefined,
+        isNullable: field.isOptional,
+        isAutoUpdated: attributeNamed(field.attributes, 'updatedAt') !== undefined,
+    };
+    if (field.isList) {
+        irField.arrayDepth = 1;
+    }
+    if (isEnum) {
+        irField.enumName = field.typeName;
+    }
+    if (rangeOf !== undefined) {
+        irField.rangeOf = rangeOf;
+    }
+    if (unsupportedType !== undefined) {
+        irField.unsupportedType = unsupportedType;
+    }
+    if (maxLength !== undefined) {
+        irField.maxLength = maxLength;
+    }
+    if (maxDigits !== undefined) {
+        irField.maxDigits = maxDigits;
+    }
+    if (decimalPlaces !== undefined) {
+        irField.decimalPlaces = decimalPlaces;
+    }
+    if (nativeAttribute !== undefined) {
+        const nativeType = {
+            name: nativeName,
+            args: nativeArguments,
+        };
+        irField.nativeType = nativeType;
+    }
+    if (attributeNamed(field.attributes, 'ignore') !== undefined) {
+        irField.isIgnored = true;
+    }
+    const uniqueAttribute = attributeNamed(field.attributes, 'unique');
+    const uniqueName = namedArgument(uniqueAttribute, 'map');
+    if (uniqueName !== undefined) {
+        irField.uniqueName = unquote(uniqueName);
+    }
+    for (const option of ['sort', 'length', 'clustered']) {
+        if (namedArgument(uniqueAttribute, option) !== undefined) {
+            warnings.push(`${location}: the @unique option "${option}" is not supported and was dropped.`);
+        }
+    }
+    const defaultAttribute = attributeNamed(field.attributes, 'default');
+    if (defaultAttribute !== undefined) {
+        const parsedDefault = parseDefault(location, defaultAttribute, field.isList, isEnum
+            ? enums.find((candidate) => candidate.name === field.typeName)
+            : undefined, warnings);
+        if (parsedDefault !== undefined) {
+            irField.default = parsedDefault;
+        }
+    }
+    return irField;
+}
+function parseDefault(location, attribute, isList, enumDefinition, warnings) {
+    const raw = positionalArgument(attribute) ?? namedArgument(attribute, 'value');
+    if (raw === undefined) {
+        return undefined;
+    }
+    const value = raw.trim();
+    if (isList) {
+        if (/^\[\s*\]$/.test(value)) {
+            return { kind: 'literal', value: '[]' };
+        }
+        warnings.push(`${location}: the list default @default(${value}) could not be converted and was dropped.`);
+        return undefined;
+    }
+    if (/^autoincrement\(\s*\)$/.test(value)) {
+        return { kind: 'autoIncrement' };
+    }
+    if (/^now\(\s*\)$/.test(value)) {
+        return { kind: 'now' };
+    }
+    const uuidMatch = /^uuid\(\s*(\d*)\s*\)$/.exec(value);
+    if (uuidMatch !== null) {
+        const version = numericArgument(uuidMatch[1]);
+        return version === undefined ? { kind: 'uuid' } : { kind: 'uuid', version };
+    }
+    const generatorMatch = /^(cuid|nanoid|ulid)\(\s*(\d*)\s*\)$/.exec(value);
+    if (generatorMatch !== null) {
+        const generatorArgs = generatorMatch[2] ?? '';
+        return {
+            kind: 'clientGenerated',
+            generator: generatorMatch[1] ?? '',
+            ...(generatorArgs === '' ? {} : { args: generatorArgs }),
+        };
+    }
+    const dbGeneratedMatch = /^dbgenerated\(\s*("(?:[^"\\]|\\.)*")\s*\)$/.exec(value);
+    if (dbGeneratedMatch !== null) {
+        return {
+            kind: 'dbExpression',
+            expression: unquote(dbGeneratedMatch[1] ?? '""'),
+        };
+    }
+    if (/^(auto|sequence)\(.*\)$/.test(value)) {
+        return { kind: 'dbExpression', expression: value, isFunction: true };
+    }
+    if (/^dbgenerated\(.*\)$/.test(value)) {
+        warnings.push(`${location}: @default(${value}) has no expression to carry over and was dropped.`);
+        return undefined;
+    }
+    if (value === 'true' || value === 'false') {
+        return { kind: 'literal', value: value === 'true' };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+        return { kind: 'literal', value: Number(value) };
+    }
+    if (value.startsWith('"')) {
+        return { kind: 'literal', value: unquote(value) };
+    }
+    if (enumDefinition !== undefined &&
+        enumDefinition.values.some((member) => member.name === value)) {
+        return { kind: 'enumValue', value };
+    }
+    warnings.push(`${location}: @default(${value}) could not be converted and was dropped.`);
+    return undefined;
+}
+//# sourceMappingURL=prisma.js.map