ormbridge 0.0.0-stage → 0.2.0

package/dist/parsers/django.js

@@ -0,0 +1,1161 @@
+import { toPascalCase } from '../naming.js';
+import { err, ok } from '../result.js';
+import { evaluateNode, getPythonParser, lastSegment, } from './pythonSyntax.js';
+const SCALAR_FIELDS = {
+    AutoField: { type: 'int', isAutoIncrement: true },
+    SmallAutoField: { type: 'int', isAutoIncrement: true },
+    BigAutoField: { type: 'bigInt', isAutoIncrement: true },
+    CharField: { type: 'string' },
+    SlugField: { type: 'string', defaultMaxLength: 50 },
+    EmailField: { type: 'string', defaultMaxLength: 254 },
+    URLField: { type: 'string', defaultMaxLength: 200 },
+    FileField: { type: 'string', defaultMaxLength: 100 },
+    ImageField: { type: 'string', defaultMaxLength: 100 },
+    FilePathField: { type: 'string', defaultMaxLength: 100 },
+    GenericIPAddressField: { type: 'ipAddress' },
+    IPAddressField: { type: 'ipAddress' },
+    CICharField: { type: 'string' },
+    CIEmailField: { type: 'string', defaultMaxLength: 254 },
+    CITextField: { type: 'text' },
+    TextField: { type: 'text' },
+    IntegerField: { type: 'int' },
+    SmallIntegerField: { type: 'int' },
+    PositiveIntegerField: { type: 'int' },
+    PositiveSmallIntegerField: { type: 'int' },
+    BigIntegerField: { type: 'bigInt' },
+    PositiveBigIntegerField: { type: 'bigInt' },
+    DurationField: { type: 'duration' },
+    FloatField: { type: 'float' },
+    DecimalField: { type: 'decimal' },
+    BooleanField: { type: 'boolean' },
+    NullBooleanField: { type: 'boolean' },
+    DateTimeField: { type: 'dateTime' },
+    DateField: { type: 'date' },
+    TimeField: { type: 'time' },
+    UUIDField: { type: 'uuid' },
+    JSONField: { type: 'json' },
+    BinaryField: { type: 'bytes' },
+    HStoreField: { type: 'hstore' },
+    IntegerRangeField: { type: 'range', rangeOf: 'int' },
+    BigIntegerRangeField: { type: 'range', rangeOf: 'bigInt' },
+    DecimalRangeField: { type: 'range', rangeOf: 'decimal' },
+    DateRangeField: { type: 'range', rangeOf: 'date' },
+    DateTimeRangeField: { type: 'range', rangeOf: 'dateTime' },
+};
+/** Virtual fields from django.contrib.contenttypes: they have no column of their own. */
+const VIRTUAL_RELATION_FIELDS = new Set([
+    'GenericForeignKey',
+    'GenericRelation',
+]);
+/**
+ * Placeholder relation targets for the user model. They are resolved once every
+ * file is read, because a model with Meta.swappable = "AUTH_USER_MODEL" defines it.
+ */
+const AUTH_USER_SETTING = 'settings.AUTH_USER_MODEL';
+const GET_USER_MODEL_CALL = 'get_user_model()';
+const RELATION_FIELDS = new Set([
+    'ForeignKey',
+    'OneToOneField',
+    'ManyToManyField',
+]);
+const ON_DELETE_MAP = {
+    CASCADE: 'cascade',
+    SET_NULL: 'setNull',
+    PROTECT: 'restrict',
+    RESTRICT: 'restrict',
+    DO_NOTHING: 'noAction',
+    SET_DEFAULT: 'setDefault',
+};
+const NOW_CALLABLES = new Set([
+    'now',
+    'timezone.now',
+    'datetime.now',
+    'datetime.datetime.now',
+]);
+/** Parses Django model files into the shared IR using tree-sitter (no Python required). */
+export async function parseDjango(sources, options) {
+    const parserResult = await getPythonParser();
+    if (!parserResult.ok) {
+        return parserResult;
+    }
+    const parser = parserResult.value;
+    const parsedFiles = sources.map((source) => parseFile(parser, source));
+    const schema = buildSchema(parsedFiles, options);
+    if (schema.models.length === 0) {
+        const checkedPaths = sources
+            .map((source) => source.path)
+            .join(', ');
+        return err('NO_MODELS_FOUND', `No concrete Django models were found in: ${checkedPaths}. A model is a class inheriting from ` +
+            `models.Model (directly, or through an abstract base) that is not marked abstract = True in its Meta class.`);
+    }
+    return ok(schema);
+}
+// ---------------------------------------------------------------------------
+// File parsing
+// ---------------------------------------------------------------------------
+function parseFile(parser, source) {
+    const warnings = [];
+    const models = [];
+    const enums = [];
+    const tree = parser.parse(source.text);
+    if (tree.rootNode.hasError) {
+        warnings.push(`${source.path}: the file contains Python syntax errors; some models or fields may be missing from the output.`);
+    }
+    const classNodes = collectTopLevelClasses(tree.rootNode);
+    const enumByClass = new Map();
+    for (const classNode of classNodes) {
+        const className = classNameOf(classNode);
+        if (isChoicesClass(classNode)) {
+            const info = parseChoicesClass(classNode, className, enums);
+            enumByClass.set(className, info);
+        }
+    }
+    for (const classNode of classNodes) {
+        const className = classNameOf(classNode);
+        if (isChoicesClass(classNode)) {
+            continue;
+        }
+        const bases = basesOf(classNode);
+        const rawModel = parseModelClass(classNode, className, bases, source, enumByClass, enums, warnings);
+        if (rawModel !== undefined) {
+            models.push(rawModel);
+        }
+    }
+    return { models, enums, warnings };
+}
+function collectTopLevelClasses(root) {
+    const classNodes = [];
+    for (const child of root.namedChildren) {
+        if (child.type === 'class_definition') {
+            classNodes.push(child);
+        }
+        else if (child.type === 'decorated_definition') {
+            const definition = child.childForFieldName('definition');
+            if (definition !== null && definition.type === 'class_definition') {
+                classNodes.push(definition);
+            }
+        }
+    }
+    return classNodes;
+}
+function classNameOf(classNode) {
+    const nameNode = classNode.childForFieldName('name');
+    return nameNode === null ? '' : nameNode.text;
+}
+function basesOf(classNode) {
+    const superclasses = classNode.childForFieldName('superclasses');
+    if (superclasses === null) {
+        return [];
+    }
+    return superclasses.namedChildren
+        .filter((child) => child.type !== 'keyword_argument' && child.type !== 'comment')
+        .map((child) => child.text.replace(/\s+/g, ''));
+}
+function bodyStatements(classNode) {
+    const body = classNode.childForFieldName('body');
+    return body === null ? [] : body.namedChildren;
+}
+const MODEL_BASE_NAMES = new Set([
+    'Model',
+    'AbstractUser',
+    'AbstractBaseUser',
+]);
+function isDjangoModelBase(baseName) {
+    return MODEL_BASE_NAMES.has(lastSegment(baseName));
+}
+/** True when the class is a model: it has fields, a Django base, or inherits from another model. */
+function isModelClass(rawModel, rawByName, visiting) {
+    if (rawModel.fields.length > 0 ||
+        rawModel.relations.length > 0 ||
+        rawModel.bases.some(isDjangoModelBase)) {
+        return true;
+    }
+    visiting.add(rawModel.name);
+    return rawModel.bases.some((baseName) => {
+        const parent = rawByName.get(lastSegment(baseName));
+        return (parent !== undefined &&
+            !visiting.has(parent.name) &&
+            isModelClass(parent, rawByName, new Set(visiting)));
+    });
+}
+function isChoicesClass(classNode) {
+    return basesOf(classNode).some((base) => /Choices$/.test(lastSegment(base)));
+}
+/** Returns the evaluated call when the statement looks like `name = something(...)`. */
+function assignmentOf(statement) {
+    if (statement.type !== 'expression_statement') {
+        return undefined;
+    }
+    const assignment = statement.namedChildren[0];
+    if (assignment === undefined || assignment.type !== 'assignment') {
+        return undefined;
+    }
+    const left = assignment.childForFieldName('left');
+    const right = assignment.childForFieldName('right');
+    if (left === null || right === null || left.type !== 'identifier') {
+        return undefined;
+    }
+    return { name: left.text, value: evaluateNode(right) };
+}
+function fieldCallOf(statement) {
+    const assignment = assignmentOf(statement);
+    if (assignment === undefined || assignment.value.kind !== 'call') {
+        return undefined;
+    }
+    const calleeName = lastSegment(assignment.value.callee);
+    if (RELATION_FIELDS.has(calleeName) ||
+        calleeName in SCALAR_FIELDS ||
+        calleeName.endsWith('Field')) {
+        return { name: assignment.name, call: assignment.value };
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Choices (TextChoices / IntegerChoices) -> enums
+// ---------------------------------------------------------------------------
+function parseChoicesClass(classNode, enumName, enums) {
+    const isInteger = basesOf(classNode).some((base) => lastSegment(base) === 'IntegerChoices');
+    if (isInteger) {
+        return { kind: 'integer' };
+    }
+    const values = [];
+    for (const statement of bodyStatements(classNode)) {
+        const assignment = assignmentOf(statement);
+        if (assignment === undefined || assignment.name.startsWith('_')) {
+            continue;
+        }
+        const value = assignment.value;
+        if (value.kind === 'string') {
+            values.push({
+                name: assignment.name,
+                dbValue: value.value,
+                label: toPascalCase(assignment.name),
+            });
+        }
+        else if (value.kind === 'list') {
+            const first = value.items[0];
+            const second = value.items[1];
+            if (first !== undefined && first.kind === 'string') {
+                const label = second !== undefined && second.kind === 'string'
+                    ? second.value
+                    : undefined;
+                values.push({
+                    name: assignment.name,
+                    dbValue: first.value,
+                    ...(label === undefined ? {} : { label }),
+                });
+            }
+        }
+    }
+    enums.push({ name: enumName, values });
+    return { kind: 'string', enumName, values };
+}
+function memberNameFromValue(rawValue, usedNames) {
+    let memberName = rawValue
+        .replace(/[^A-Za-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toUpperCase();
+    if (memberName.length === 0 || /^[0-9]/.test(memberName)) {
+        memberName = `V_${memberName}`;
+    }
+    let candidate = memberName;
+    let suffix = 2;
+    while (usedNames.has(candidate)) {
+        candidate = `${memberName}_${suffix}`;
+        suffix += 1;
+    }
+    usedNames.add(candidate);
+    return candidate;
+}
+// ---------------------------------------------------------------------------
+// Model classes
+// ---------------------------------------------------------------------------
+function parseModelClass(classNode, className, bases, source, fileEnums, allEnums, warnings) {
+    const enumByClass = new Map(fileEnums);
+    const statements = bodyStatements(classNode);
+    // Nested Choices classes are namespaced by their model to keep enum names unique.
+    for (const statement of statements) {
+        if (statement.type === 'class_definition' && isChoicesClass(statement)) {
+            const nestedName = classNameOf(statement);
+            const info = parseChoicesClass(statement, `${className}${nestedName}`, allEnums);
+            enumByClass.set(nestedName, info);
+        }
+    }
+    const fieldContext = {
+        modelName: className,
+        enumByClass,
+        newEnums: allEnums,
+        warnings,
+    };
+    const fields = [];
+    const relations = [];
+    const indexes = [];
+    let meta = { isAbstract: false, isProxy: false, indexes: [] };
+    let compositePrimaryKey;
+    for (const statement of statements) {
+        if (statement.type === 'class_definition' &&
+            classNameOf(statement) === 'Meta') {
+            meta = parseMeta(statement, `${source.path}: ${className}.Meta`, warnings);
+            continue;
+        }
+        const special = parseSpecialAttribute(statement, className, warnings);
+        if (special.consumed) {
+            if (special.compositeKey !== undefined) {
+                compositePrimaryKey = special.compositeKey;
+            }
+            continue;
+        }
+        const fieldCall = fieldCallOf(statement);
+        if (fieldCall === undefined) {
+            continue;
+        }
+        const parsed = parseFieldCall(fieldCall.name, fieldCall.call, fieldContext);
+        if (parsed.field !== undefined) {
+            fields.push(parsed.field);
+        }
+        if (parsed.relation !== undefined) {
+            relations.push(parsed.relation);
+        }
+        if (parsed.index !== undefined) {
+            indexes.push(parsed.index);
+        }
+    }
+    if (bases.length === 0 && fields.length === 0 && relations.length === 0) {
+        // A plain Python class with no bases and no model fields (helper, constants): not a model.
+        return undefined;
+    }
+    return {
+        name: className,
+        appLabel: meta.appLabel ?? source.appLabel,
+        filePath: source.path,
+        bases,
+        isAbstract: meta.isAbstract,
+        isProxy: meta.isProxy,
+        ...(meta.swappable === undefined ? {} : { swappable: meta.swappable }),
+        ...(meta.tableName === undefined ? {} : { tableName: meta.tableName }),
+        ...(compositePrimaryKey === undefined ? {} : { compositePrimaryKey }),
+        fields,
+        relations,
+        indexes: [...indexes, ...meta.indexes],
+    };
+}
+/** Handles class attributes that are not ordinary columns (CompositePrimaryKey, generic relations). */
+function parseSpecialAttribute(statement, className, warnings) {
+    const assignment = assignmentOf(statement);
+    if (assignment === undefined || assignment.value.kind !== 'call') {
+        return { consumed: false };
+    }
+    const calleeName = lastSegment(assignment.value.callee);
+    if (calleeName === 'CompositePrimaryKey') {
+        const names = assignment.value.args.flatMap((arg) => arg.kind === 'string' ? [arg.value] : []);
+        if (names.length === 0) {
+            warnings.push(`${className}.${assignment.name}: CompositePrimaryKey(...) lists no field names that could be read; the model keeps an automatic id.`);
+            return { consumed: true };
+        }
+        return { consumed: true, compositeKey: names };
+    }
+    if (VIRTUAL_RELATION_FIELDS.has(calleeName)) {
+        warnings.push(`${className}.${assignment.name}: ${calleeName} is a virtual field without a column and was skipped; ` +
+            `its content_type and object_id columns are converted as ordinary fields.`);
+        return { consumed: true };
+    }
+    return { consumed: false };
+}
+function parseMeta(metaNode, location, warnings) {
+    const meta = { isAbstract: false, isProxy: false, indexes: [] };
+    for (const statement of bodyStatements(metaNode)) {
+        const assignment = assignmentOf(statement);
+        if (assignment === undefined) {
+            continue;
+        }
+        const value = assignment.value;
+        switch (assignment.name) {
+            case 'abstract':
+                meta.isAbstract = value.kind === 'bool' && value.value;
+                break;
+            case 'proxy':
+                meta.isProxy = value.kind === 'bool' && value.value;
+                break;
+            case 'swappable':
+                if (value.kind === 'string') {
+                    meta.swappable = value.value;
+                }
+                break;
+            case 'db_table':
+                if (value.kind === 'string') {
+                    meta.tableName = value.value;
+                }
+                break;
+            case 'app_label':
+                if (value.kind === 'string') {
+                    meta.appLabel = value.value;
+                }
+                break;
+            case 'managed':
+                if (value.kind === 'bool' && !value.value) {
+                    warnings.push(`${location}: managed = False is ignored; the model is converted like any other table.`);
+                }
+                break;
+            case 'unique_together':
+                meta.indexes.push(...parseUniqueTogether(value));
+                break;
+            case 'index_together':
+                meta.indexes.push(...parseUniqueTogether(value).map((index) => ({
+                    ...index,
+                    isUnique: false,
+                })));
+                break;
+            case 'indexes':
+                meta.indexes.push(...parseIndexList(value, false, location, warnings));
+                break;
+            case 'constraints':
+                meta.indexes.push(...parseIndexList(value, true, location, warnings));
+                break;
+            default:
+                break;
+        }
+    }
+    return meta;
+}
+function stringItems(value) {
+    if (value === undefined) {
+        return [];
+    }
+    if (value.kind === 'string') {
+        return [value.value];
+    }
+    if (value.kind === 'list') {
+        return value.items.flatMap((item) => item.kind === 'string' ? [item.value.replace(/^-/, '')] : []);
+    }
+    return [];
+}
+function parseUniqueTogether(value) {
+    if (value.kind !== 'list') {
+        return [];
+    }
+    const allStrings = value.items.every((item) => item.kind === 'string');
+    if (allStrings) {
+        return [{ fields: stringItems(value), isUnique: true }];
+    }
+    return value.items
+        .map((item) => ({
+        fields: stringItems(item),
+        isUnique: true,
+    }))
+        .filter((index) => index.fields.length > 0);
+}
+function parseIndexList(value, constraintsOnly, location, warnings) {
+    if (value.kind !== 'list') {
+        return [];
+    }
+    const indexes = [];
+    for (const item of value.items) {
+        if (item.kind !== 'call') {
+            continue;
+        }
+        const calleeName = lastSegment(item.callee);
+        if (calleeName === 'UniqueConstraint' &&
+            item.kwargs['condition'] !== undefined) {
+            warnings.push(`${location}: UniqueConstraint(...) with condition= is a partial unique constraint and was skipped; ` +
+                `converting it would make the columns unconditionally unique.`);
+            continue;
+        }
+        const fields = stringItems(item.kwargs['fields']);
+        const explicitName = item.kwargs['name'];
+        const name = explicitName !== undefined && explicitName.kind === 'string'
+            ? explicitName.value
+            : undefined;
+        if (calleeName === 'Index' && !constraintsOnly && fields.length > 0) {
+            indexes.push({
+                fields,
+                isUnique: false,
+                ...(name === undefined ? {} : { name }),
+            });
+        }
+        else if (calleeName === 'UniqueConstraint' && fields.length > 0) {
+            indexes.push({
+                fields,
+                isUnique: true,
+                ...(name === undefined ? {} : { name }),
+            });
+        }
+        else if (calleeName === 'CheckConstraint' ||
+            calleeName === 'UniqueConstraint' ||
+            calleeName === 'Index') {
+            warnings.push(`${location}: ${calleeName}(...) could not be converted (only field-based indexes and unique constraints are supported).`);
+        }
+    }
+    return indexes;
+}
+function boolKwarg(call, key) {
+    const value = call.kwargs[key];
+    return value !== undefined && value.kind === 'bool' && value.value;
+}
+function stringKwarg(call, key) {
+    const value = call.kwargs[key];
+    return value !== undefined && value.kind === 'string'
+        ? value.value
+        : undefined;
+}
+function numberKwarg(call, key) {
+    const value = call.kwargs[key];
+    return value !== undefined && value.kind === 'number'
+        ? value.value
+        : undefined;
+}
+function parseFieldCall(fieldName, call, context) {
+    const calleeName = lastSegment(call.callee);
+    if (RELATION_FIELDS.has(calleeName)) {
+        return parseRelationField(fieldName, calleeName, call, context);
+    }
+    if (calleeName === 'ArrayField') {
+        return parseArrayField(fieldName, call, context);
+    }
+    if (calleeName === 'GeneratedField') {
+        return parseGeneratedField(fieldName, call, context);
+    }
+    return parseScalarField(fieldName, calleeName, call, context);
+}
+function syntheticCall(callee) {
+    return { kind: 'call', callee, args: [], kwargs: {}, text: `${callee}()` };
+}
+/** Returns Python source text for an evaluated expression (used for GeneratedField). */
+function sourceTextOf(value) {
+    switch (value.kind) {
+        case 'call':
+            return value.text;
+        case 'name':
+            return value.value;
+        case 'other':
+            return value.text.replace(/\s*\n\s*/g, ' ');
+        case 'string':
+            return JSON.stringify(value.value);
+        case 'number':
+            return String(value.value);
+        case 'bool':
+            return value.value ? 'True' : 'False';
+        case 'none':
+            return 'None';
+        case 'list':
+            return `[${value.items.map(sourceTextOf).join(', ')}]`;
+        default:
+            return '';
+    }
+}
+/** django.contrib.postgres ArrayField: the element type is the base_field, nested arrays add dimensions. */
+function parseArrayField(fieldName, call, context) {
+    const location = `${context.modelName}.${fieldName}`;
+    const baseValue = call.args[0] ?? call.kwargs['base_field'];
+    let elementCall;
+    if (baseValue !== undefined && baseValue.kind === 'call') {
+        elementCall = baseValue;
+    }
+    else {
+        context.warnings.push(`${location}: the base_field of ArrayField(...) could not be read; the elements were assumed to be strings.`);
+        elementCall = syntheticCall('CharField');
+    }
+    const element = parseFieldCall(fieldName, elementCall, context);
+    if (element.field === undefined) {
+        context.warnings.push(`${location}: the base_field of ArrayField(...) is not a column type; the field was skipped.`);
+        return {};
+    }
+    if (call.kwargs['size'] !== undefined) {
+        context.warnings.push(`${location}: ArrayField size= is not represented in the schema; arrays are unbounded.`);
+    }
+    const isPrimaryKey = boolKwarg(call, 'primary_key');
+    const field = {
+        ...element.field,
+        name: fieldName,
+        columnName: stringKwarg(call, 'db_column') ?? fieldName,
+        isPrimaryKey,
+        isUnique: boolKwarg(call, 'unique') && !isPrimaryKey,
+        isNullable: !isPrimaryKey && boolKwarg(call, 'null'),
+        isAutoUpdated: false,
+        arrayDepth: (element.field.arrayDepth ?? 0) + 1,
+    };
+    delete field.default;
+    delete field.isDbDefault;
+    const spec = { type: field.type };
+    const defaultValue = resolveDefault(location, call, spec, undefined, context, 'default', true);
+    if (defaultValue !== undefined) {
+        field.default = defaultValue;
+    }
+    else if (call.kwargs['db_default'] !== undefined) {
+        const dbDefault = resolveDefault(location, call, spec, undefined, context, 'db_default', true);
+        if (dbDefault !== undefined) {
+            field.default = dbDefault;
+            field.isDbDefault = true;
+        }
+    }
+    const parsed = { field };
+    if (boolKwarg(call, 'db_index') && !isPrimaryKey && !field.isUnique) {
+        parsed.index = { fields: [fieldName], isUnique: false };
+    }
+    return parsed;
+}
+/** GeneratedField: the column type comes from output_field, the expression is carried as source text. */
+function parseGeneratedField(fieldName, call, context) {
+    const location = `${context.modelName}.${fieldName}`;
+    const outputValue = call.kwargs['output_field'];
+    let outputCall;
+    if (outputValue !== undefined && outputValue.kind === 'call') {
+        outputCall = outputValue;
+    }
+    else {
+        context.warnings.push(`${location}: the output_field of GeneratedField(...) could not be read; the column was typed as a string.`);
+        outputCall = syntheticCall('CharField');
+    }
+    const output = parseFieldCall(fieldName, outputCall, context);
+    if (output.field === undefined) {
+        context.warnings.push(`${location}: the output_field of GeneratedField(...) is not a column type; the field was skipped.`);
+        return {};
+    }
+    const expression = call.kwargs['expression'] ?? call.args[0];
+    const expressionText = expression === undefined ? '' : sourceTextOf(expression);
+    const persist = call.kwargs['db_persist'];
+    const field = {
+        ...output.field,
+        name: fieldName,
+        columnName: stringKwarg(call, 'db_column') ?? fieldName,
+        isPrimaryKey: false,
+        isUnique: boolKwarg(call, 'unique'),
+        isNullable: output.field.isNullable || boolKwarg(call, 'null'),
+        isAutoUpdated: false,
+    };
+    delete field.default;
+    delete field.isDbDefault;
+    if (expressionText.length === 0) {
+        context.warnings.push(`${location}: GeneratedField(...) has no readable expression=; it was converted as a plain column.`);
+    }
+    else {
+        field.generated = {
+            expression: expressionText,
+            isStored: !(persist !== undefined &&
+                persist.kind === 'bool' &&
+                !persist.value),
+        };
+    }
+    return { field };
+}
+function parseScalarField(fieldName, calleeName, call, context) {
+    const location = `${context.modelName}.${fieldName}`;
+    let spec = SCALAR_FIELDS[calleeName];
+    if (spec === undefined) {
+        context.warnings.push(`${location}: unknown field type "${calleeName}"; it was converted as a plain string column. ` +
+            `Review the generated type.`);
+        spec = { type: 'string' };
+    }
+    const isPrimaryKey = boolKwarg(call, 'primary_key');
+    const field = {
+        name: fieldName,
+        columnName: stringKwarg(call, 'db_column') ?? fieldName,
+        type: spec.type,
+        ...(spec.rangeOf === undefined ? {} : { rangeOf: spec.rangeOf }),
+        isPrimaryKey,
+        isUnique: boolKwarg(call, 'unique') && !isPrimaryKey,
+        isNullable: !isPrimaryKey &&
+            (boolKwarg(call, 'null') || calleeName === 'NullBooleanField'),
+        isAutoUpdated: boolKwarg(call, 'auto_now'),
+    };
+    const maxLength = numberKwarg(call, 'max_length') ?? spec.defaultMaxLength;
+    if (maxLength !== undefined &&
+        (spec.type === 'string' || spec.type === 'text')) {
+        field.maxLength = maxLength;
+    }
+    if (spec.type === 'decimal') {
+        const maxDigits = numberKwarg(call, 'max_digits');
+        const decimalPlaces = numberKwarg(call, 'decimal_places');
+        if (maxDigits !== undefined) {
+            field.maxDigits = maxDigits;
+        }
+        if (decimalPlaces !== undefined) {
+            field.decimalPlaces = decimalPlaces;
+        }
+    }
+    const enumInfo = resolveChoices(fieldName, call, context);
+    if (enumInfo !== undefined && enumInfo.kind === 'string') {
+        field.enumName = enumInfo.enumName;
+        field.type = 'string';
+    }
+    let defaultValue = resolveDefault(location, call, spec, enumInfo, context, 'default', false);
+    if (call.kwargs['db_default'] !== undefined) {
+        if (defaultValue !== undefined) {
+            context.warnings.push(`${location}: db_default was ignored because default= is also set.`);
+        }
+        else {
+            defaultValue = resolveDefault(location, call, spec, enumInfo, context, 'db_default', false);
+            if (defaultValue !== undefined) {
+                field.isDbDefault = true;
+            }
+        }
+    }
+    if (defaultValue !== undefined) {
+        field.default = defaultValue;
+    }
+    else if (spec.isAutoIncrement === true) {
+        field.default = { kind: 'autoIncrement' };
+    }
+    if (boolKwarg(call, 'auto_now_add')) {
+        field.default = { kind: 'now' };
+    }
+    const parsed = { field };
+    if (boolKwarg(call, 'db_index') && !isPrimaryKey && !field.isUnique) {
+        parsed.index = { fields: [fieldName], isUnique: false };
+    }
+    return parsed;
+}
+function resolveChoices(fieldName, call, context) {
+    const choices = call.kwargs['choices'];
+    if (choices === undefined) {
+        return undefined;
+    }
+    if (choices.kind === 'name') {
+        const className = choices.value.split('.')[0] ?? '';
+        return context.enumByClass.get(className);
+    }
+    if (choices.kind === 'list') {
+        const usedNames = new Set();
+        const values = [];
+        for (const item of choices.items) {
+            if (item.kind !== 'list') {
+                continue;
+            }
+            const first = item.items[0];
+            const second = item.items[1];
+            if (first !== undefined && first.kind === 'string') {
+                const label = second !== undefined && second.kind === 'string'
+                    ? second.value
+                    : undefined;
+                values.push({
+                    name: memberNameFromValue(first.value, usedNames),
+                    dbValue: first.value,
+                    ...(label === undefined ? {} : { label }),
+                });
+            }
+        }
+        if (values.length === 0) {
+            return undefined;
+        }
+        const enumName = `${context.modelName}${toPascalCase(fieldName)}`;
+        context.newEnums.push({ name: enumName, values });
+        return { kind: 'string', enumName, values };
+    }
+    return undefined;
+}
+/** Unwraps the expression forms db_default accepts (Value(x), Now(), RandomUUID()) into plain defaults. */
+function unwrapDbDefault(value) {
+    if (value.kind !== 'call') {
+        return value;
+    }
+    const calleeName = lastSegment(value.callee);
+    const first = value.args[0];
+    if (calleeName === 'Value' && first !== undefined) {
+        return first;
+    }
+    if (calleeName === 'Now' && value.args.length === 0) {
+        return { kind: 'name', value: 'now' };
+    }
+    if (calleeName === 'RandomUUID' && value.args.length === 0) {
+        return { kind: 'name', value: 'uuid.uuid4' };
+    }
+    return value;
+}
+function resolveDefault(location, call, spec, enumInfo, context, kwarg, isArray) {
+    const rawValue = call.kwargs[kwarg];
+    if (rawValue === undefined || rawValue.kind === 'none') {
+        return undefined;
+    }
+    const value = kwarg === 'db_default' ? unwrapDbDefault(rawValue) : rawValue;
+    const emptyListAllowed = spec.type === 'json' || isArray;
+    switch (value.kind) {
+        case 'list':
+            if (value.items.length === 0 && emptyListAllowed) {
+                return { kind: 'literal', value: '[]' };
+            }
+            context.warnings.push(`${location}: ${kwarg}=[...] is not representable and was dropped.`);
+            return undefined;
+        case 'other':
+            if (value.text.replace(/\s+/g, '') === '{}' &&
+                (spec.type === 'json' || spec.type === 'hstore')) {
+                return { kind: 'literal', value: '{}' };
+            }
+            context.warnings.push(`${location}: a computed ${kwarg} value was dropped (only literals and now/uuid are supported).`);
+            return undefined;
+        case 'bool':
+        case 'number':
+            return { kind: 'literal', value: value.value };
+        case 'string': {
+            if (enumInfo !== undefined && enumInfo.kind === 'string') {
+                const member = enumInfo.values.find((enumValue) => enumValue.dbValue === value.value);
+                if (member !== undefined) {
+                    return { kind: 'enumValue', value: member.name };
+                }
+            }
+            return { kind: 'literal', value: value.value };
+        }
+        case 'name': {
+            const dotted = value.value;
+            if (dotted === 'uuid.uuid4' ||
+                dotted === 'uuid4' ||
+                dotted === 'uuid.uuid1') {
+                return { kind: 'uuid' };
+            }
+            if (NOW_CALLABLES.has(dotted) || dotted.endsWith('timezone.now')) {
+                return { kind: 'now' };
+            }
+            if (dotted === 'list' && emptyListAllowed) {
+                return { kind: 'literal', value: '[]' };
+            }
+            if (dotted === 'dict' &&
+                (spec.type === 'json' || spec.type === 'hstore')) {
+                return { kind: 'literal', value: '{}' };
+            }
+            const segments = dotted.split('.');
+            const memberName = segments[1];
+            const enumClass = context.enumByClass.get(segments[0] ?? '');
+            if (enumClass !== undefined &&
+                enumClass.kind === 'string' &&
+                memberName !== undefined) {
+                return { kind: 'enumValue', value: memberName };
+            }
+            if (enumClass !== undefined && enumClass.kind === 'integer') {
+                return undefined;
+            }
+            context.warnings.push(`${location}: ${kwarg}=${dotted} is not representable and was dropped.`);
+            return undefined;
+        }
+        case 'call': {
+            const arg = value.args[0];
+            if (lastSegment(value.callee) === 'Decimal' && arg !== undefined) {
+                if (arg.kind === 'string' && !Number.isNaN(Number(arg.value))) {
+                    return { kind: 'literal', value: Number(arg.value) };
+                }
+                if (arg.kind === 'number') {
+                    return { kind: 'literal', value: arg.value };
+                }
+            }
+            context.warnings.push(`${location}: ${kwarg}=${value.callee}(...) is not representable and was dropped.`);
+            return undefined;
+        }
+        default:
+            context.warnings.push(`${location}: a computed ${kwarg} value was dropped (only literals and now/uuid are supported).`);
+            return undefined;
+    }
+}
+function parseRelationField(fieldName, calleeName, call, context) {
+    const location = `${context.modelName}.${fieldName}`;
+    const target = resolveRelationTarget(call, context);
+    if (target === undefined) {
+        context.warnings.push(`${location}: could not determine the target model of ${calleeName}(...); the field was skipped.`);
+        return {};
+    }
+    if (calleeName === 'ManyToManyField' &&
+        call.kwargs['through'] !== undefined) {
+        context.warnings.push(`${location}: ManyToManyField with through= was skipped; the explicit through model carries the relations.`);
+        return {};
+    }
+    const relatedNameValue = stringKwarg(call, 'related_name');
+    const relatedName = relatedNameValue === undefined || relatedNameValue.endsWith('+')
+        ? undefined
+        : relatedNameValue;
+    const toField = stringKwarg(call, 'to_field');
+    let kind = 'foreignKey';
+    if (calleeName === 'OneToOneField') {
+        kind = 'oneToOne';
+    }
+    else if (calleeName === 'ManyToManyField') {
+        kind = 'manyToMany';
+    }
+    else if (boolKwarg(call, 'unique')) {
+        kind = 'oneToOne';
+    }
+    const relation = {
+        name: fieldName,
+        kind,
+        targetModel: target,
+        columnName: stringKwarg(call, 'db_column') ?? `${fieldName}_id`,
+        isNullable: boolKwarg(call, 'null'),
+        onDelete: resolveOnDelete(location, call, context),
+        ...(relatedName === undefined ? {} : { relatedName }),
+        ...(toField === undefined ? {} : { toField }),
+        ...(boolKwarg(call, 'primary_key') ? { isPrimaryKey: true } : {}),
+    };
+    return { relation };
+}
+function resolveRelationTarget(call, context) {
+    const targetValue = call.args[0] ?? call.kwargs['to'];
+    if (targetValue === undefined) {
+        return undefined;
+    }
+    switch (targetValue.kind) {
+        case 'string':
+            return targetValue.value === 'self'
+                ? context.modelName
+                : lastSegment(targetValue.value);
+        case 'name':
+            if (lastSegment(targetValue.value) === 'AUTH_USER_MODEL') {
+                return AUTH_USER_SETTING;
+            }
+            return lastSegment(targetValue.value);
+        case 'call':
+            if (lastSegment(targetValue.callee) === 'get_user_model') {
+                return GET_USER_MODEL_CALL;
+            }
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+function resolveOnDelete(location, call, context) {
+    const value = call.kwargs['on_delete'] ?? call.args[1];
+    if (value === undefined) {
+        return 'cascade';
+    }
+    const rawName = value.kind === 'name'
+        ? lastSegment(value.value)
+        : value.kind === 'call'
+            ? lastSegment(value.callee)
+            : '';
+    const mapped = ON_DELETE_MAP[rawName];
+    if (mapped !== undefined) {
+        return mapped;
+    }
+    context.warnings.push(`${location}: on_delete=${rawName || 'unknown'} has no equivalent and was converted to NoAction.`);
+    return 'noAction';
+}
+const KNOWN_EXTERNAL_BASES = new Set([
+    'Model',
+    'AbstractUser',
+    'AbstractBaseUser',
+    'PermissionsMixin',
+    'Manager',
+]);
+function buildSchema(parsedFiles, options) {
+    const warnings = parsedFiles.flatMap((file) => file.warnings);
+    const enumsByName = new Map();
+    for (const file of parsedFiles) {
+        for (const enumDefinition of file.enums) {
+            enumsByName.set(enumDefinition.name, enumDefinition);
+        }
+    }
+    const rawByName = new Map();
+    for (const file of parsedFiles) {
+        for (const rawModel of file.models) {
+            if (rawByName.has(rawModel.name)) {
+                warnings.push(`Duplicate model name "${rawModel.name}" (${rawModel.filePath}); only the first definition was converted.`);
+                continue;
+            }
+            rawByName.set(rawModel.name, rawModel);
+        }
+    }
+    retargetUserModel(rawByName, warnings);
+    retargetProxies(rawByName, warnings);
+    const models = [];
+    for (const rawModel of rawByName.values()) {
+        if (rawModel.isAbstract ||
+            rawModel.isProxy ||
+            !isModelClass(rawModel, rawByName, new Set())) {
+            continue;
+        }
+        const members = collectMembers(rawModel, rawByName, warnings, new Set());
+        models.push(finalizeModel(rawModel, members, options));
+    }
+    addStubModels(models, rawByName, warnings, options);
+    return { models, enums: [...enumsByName.values()], warnings };
+}
+/** Points relations at settings.AUTH_USER_MODEL / get_user_model() to the swappable model, or "User" with a warning. */
+function retargetUserModel(rawByName, warnings) {
+    let swappableName;
+    for (const rawModel of rawByName.values()) {
+        if (rawModel.swappable === 'AUTH_USER_MODEL' && !rawModel.isProxy) {
+            swappableName = rawModel.name;
+            break;
+        }
+    }
+    for (const rawModel of rawByName.values()) {
+        for (const relation of rawModel.relations) {
+            if (relation.targetModel !== AUTH_USER_SETTING &&
+                relation.targetModel !== GET_USER_MODEL_CALL) {
+                continue;
+            }
+            if (swappableName !== undefined) {
+                relation.targetModel = swappableName;
+                continue;
+            }
+            warnings.push(relation.targetModel === AUTH_USER_SETTING
+                ? `${rawModel.name}.${relation.name}: settings.AUTH_USER_MODEL was assumed to be a model named "User".`
+                : `${rawModel.name}.${relation.name}: get_user_model() was assumed to return a model named "User".`);
+            relation.targetModel = 'User';
+        }
+    }
+}
+/** Names the concrete model a proxy model stands for, following chains of proxies. */
+function concreteModelOf(proxy, rawByName, visiting) {
+    visiting.add(proxy.name);
+    for (const baseName of proxy.bases) {
+        const shortName = lastSegment(baseName);
+        if (shortName === 'Model' || /Mixin$/.test(shortName)) {
+            continue;
+        }
+        const parent = rawByName.get(shortName);
+        if (parent === undefined) {
+            return shortName;
+        }
+        if (parent.isAbstract || visiting.has(parent.name)) {
+            continue;
+        }
+        return parent.isProxy
+            ? concreteModelOf(parent, rawByName, visiting)
+            : parent.name;
+    }
+    return undefined;
+}
+/**
+ * A proxy model (Meta.proxy = True) shares its parent's table, so it is not a model of its
+ * own: relations that target it are pointed at the concrete model instead.
+ */
+function retargetProxies(rawByName, warnings) {
+    const concreteByProxy = new Map();
+    for (const rawModel of rawByName.values()) {
+        if (!rawModel.isProxy) {
+            continue;
+        }
+        const concrete = concreteModelOf(rawModel, rawByName, new Set());
+        if (concrete === undefined) {
+            warnings.push(`${rawModel.name}: proxy model has no concrete base model that could be found, so it was skipped.`);
+            continue;
+        }
+        concreteByProxy.set(rawModel.name, concrete);
+        warnings.push(`${rawModel.name}: proxy model of "${concrete}" has no table of its own and was merged into "${concrete}"; ` +
+            `relations that target "${rawModel.name}" now point to "${concrete}".`);
+    }
+    if (concreteByProxy.size === 0) {
+        return;
+    }
+    for (const rawModel of rawByName.values()) {
+        for (const relation of rawModel.relations) {
+            const concrete = concreteByProxy.get(relation.targetModel);
+            if (concrete !== undefined) {
+                relation.targetModel = concrete;
+            }
+        }
+    }
+}
+function collectMembers(rawModel, rawByName, warnings, visiting) {
+    const inherited = { fields: [], relations: [], indexes: [] };
+    visiting.add(rawModel.name);
+    for (const baseName of rawModel.bases) {
+        const shortName = lastSegment(baseName);
+        const parent = rawByName.get(shortName);
+        if (parent === undefined) {
+            if (!KNOWN_EXTERNAL_BASES.has(shortName)) {
+                warnings.push(`${rawModel.name}: base class "${baseName}" was not found in the input files, so any fields it defines ` +
+                    `are missing. Add the file that defines it to --input.`);
+            }
+            else if (shortName !== 'Model') {
+                warnings.push(`${rawModel.name}: fields inherited from django.contrib.auth "${shortName}" are not included; ` +
+                    `add them to the output manually.`);
+            }
+            continue;
+        }
+        if (visiting.has(parent.name)) {
+            warnings.push(`${rawModel.name}: circular inheritance through "${parent.name}" was ignored.`);
+            continue;
+        }
+        if (parent.isAbstract) {
+            const parentMembers = collectMembers(parent, rawByName, warnings, new Set(visiting));
+            inherited.fields.push(...parentMembers.fields);
+            inherited.relations.push(...parentMembers.relations);
+            inherited.indexes.push(...parentMembers.indexes);
+        }
+        else {
+            const pointerName = `${parent.name.toLowerCase()}_ptr`;
+            inherited.relations.push({
+                name: pointerName,
+                kind: 'oneToOne',
+                targetModel: parent.name,
+                columnName: `${pointerName}_id`,
+                isNullable: false,
+                onDelete: 'cascade',
+                isPrimaryKey: true,
+            });
+            warnings.push(`${rawModel.name}: multi-table inheritance from "${parent.name}" was converted to a one-to-one primary key ` +
+                `named "${pointerName}".`);
+        }
+    }
+    const ownFieldNames = new Set(rawModel.fields.map((field) => field.name));
+    const ownRelationNames = new Set(rawModel.relations.map((relation) => relation.name));
+    return {
+        fields: [
+            ...inherited.fields.filter((field) => !ownFieldNames.has(field.name)),
+            ...rawModel.fields,
+        ],
+        relations: [
+            ...inherited.relations.filter((relation) => !ownRelationNames.has(relation.name)),
+            ...rawModel.relations,
+        ],
+        indexes: [...inherited.indexes, ...rawModel.indexes],
+    };
+}
+function autoPrimaryKey(options) {
+    return {
+        name: 'id',
+        columnName: 'id',
+        type: options.autoField,
+        isPrimaryKey: true,
+        isUnique: false,
+        isNullable: false,
+        isAutoUpdated: false,
+        default: { kind: 'autoIncrement' },
+    };
+}
+function finalizeModel(rawModel, members, options) {
+    const hasCompositeKey = rawModel.compositePrimaryKey !== undefined &&
+        rawModel.compositePrimaryKey.length > 0;
+    const hasPrimaryKey = hasCompositeKey ||
+        members.fields.some((field) => field.isPrimaryKey) ||
+        members.relations.some((relation) => relation.isPrimaryKey === true);
+    const fields = hasPrimaryKey
+        ? members.fields
+        : [autoPrimaryKey(options), ...members.fields];
+    return {
+        name: rawModel.name,
+        tableName: rawModel.tableName ??
+            `${rawModel.appLabel}_${rawModel.name.toLowerCase()}`,
+        appLabel: rawModel.appLabel,
+        fields,
+        relations: members.relations,
+        indexes: members.indexes,
+        ...(hasCompositeKey && rawModel.compositePrimaryKey !== undefined
+            ? { compositePrimaryKey: rawModel.compositePrimaryKey }
+            : {}),
+    };
+}
+function addStubModels(models, rawByName, warnings, options) {
+    const known = new Set(models.map((model) => model.name));
+    const stubs = [];
+    for (const model of models) {
+        for (const relation of model.relations) {
+            const target = relation.targetModel;
+            if (known.has(target) || rawByName.has(target)) {
+                continue;
+            }
+            known.add(target);
+            const isUserModel = target === 'User';
+            stubs.push({
+                name: target,
+                tableName: isUserModel
+                    ? 'auth_user'
+                    : `${model.appLabel}_${target.toLowerCase()}`,
+                appLabel: isUserModel ? 'auth' : model.appLabel,
+                fields: [autoPrimaryKey(options)],
+                relations: [],
+                indexes: [],
+            });
+            warnings.push(`${model.name}.${relation.name} references model "${target}", which was not found in the input. ` +
+                `A stub model with an auto-increment id was generated; replace it with the real definition.`);
+        }
+    }
+    models.push(...stubs);
+}
+//# sourceMappingURL=django.js.map