ormbridge 0.13.0 → 0.15.0

package/dist/parsers/zodFields.js

@@ -0,0 +1,681 @@
+import { functionResult, isFunctionNode, literalOf, objectMembers, stripWrappers, unwindChain, } from './zodSyntax.js';
+const MAX_DEPTH = 24;
+const STRING_FORMAT_BASES = {
+    uuid: 'uuid',
+    guid: 'plain',
+    uuidv4: 'uuid',
+    uuidv6: 'uuid',
+    uuidv7: 'uuid',
+    email: 'plain',
+    url: 'plain',
+    httpUrl: 'plain',
+    emoji: 'plain',
+    nanoid: 'plain',
+    cuid: 'plain',
+    cuid2: 'plain',
+    ulid: 'plain',
+    xid: 'plain',
+    ksuid: 'plain',
+    jwt: 'plain',
+    hostname: 'plain',
+    e164: 'plain',
+    cidrv4: 'plain',
+    cidrv6: 'plain',
+    ipv4: 'ipAddress',
+    ipv6: 'ipAddress',
+    base64: 'bytes',
+    base64url: 'plain',
+    hex: 'plain',
+    'iso.datetime': 'dateTime',
+    'iso.date': 'date',
+    'iso.time': 'time',
+    'iso.duration': 'duration',
+};
+/** Format methods of a Zod 3 / Zod 4 string (`z.string().uuid()`). */
+const STRING_FORMAT_STEPS = {
+    uuid: 'uuid',
+    guid: 'plain',
+    email: 'plain',
+    url: 'plain',
+    emoji: 'plain',
+    nanoid: 'plain',
+    cuid: 'plain',
+    cuid2: 'plain',
+    ulid: 'plain',
+    xid: 'plain',
+    ksuid: 'plain',
+    jwt: 'plain',
+    e164: 'plain',
+    cidr: 'plain',
+    ip: 'ipAddress',
+    ipv4: 'ipAddress',
+    ipv6: 'ipAddress',
+    base64: 'bytes',
+    base64url: 'plain',
+    datetime: 'dateTime',
+    date: 'date',
+    time: 'time',
+    duration: 'duration',
+};
+const JSON_BASES = new Set([
+    'any',
+    'unknown',
+    'json',
+    'record',
+    'partialRecord',
+    'looseRecord',
+    'map',
+]);
+/** Constructors that describe no stored value: they become json, with a warning. */
+const NO_COLUMN_BASES = new Set([
+    'custom',
+    'instanceof',
+    'function',
+    'promise',
+    'symbol',
+    'void',
+    'never',
+    'nan',
+    'codec',
+]);
+export const OBJECT_BASES = new Set([
+    'object',
+    'strictObject',
+    'looseObject',
+    'interface',
+    'strictInterface',
+]);
+/** Wrappers written as functions (`z.optional(inner)`): the schema is the first argument. */
+const WRAPPER_BASES = new Set([
+    'optional',
+    'nullable',
+    'nullish',
+    'readonly',
+    'lazy',
+    'nonoptional',
+    'brand',
+    'catch',
+    'default',
+    'prefault',
+]);
+/** Modifiers that change nothing the shared model stores and are not worth mentioning. */
+const SILENT_STEPS = new Set(['describe', 'meta']);
+const DECIMAL_UNSIZED = '/^-?\\d+(\\.\\d+)?$/';
+const BIGINT_PATTERN = '/^-?\\d+$/';
+const DECIMAL_SIZED = /^\/\^-\?\\d\{1,(\d+)\}(?:\(\\\.\\d\{1,(\d+)\}\)\?)?\$\/$/;
+function emptyField(type) {
+    return {
+        type,
+        arrayDepth: 0,
+        optional: false,
+        nullable: false,
+        hasDefault: false,
+        dropped: [],
+        problems: [],
+    };
+}
+function jsonField(problem) {
+    const field = emptyField('json');
+    if (problem !== undefined) {
+        field.problems.push(problem);
+    }
+    return field;
+}
+function stepText(step) {
+    const first = step.args[0];
+    const text = first === undefined || isFunctionNode(stripWrappers(first))
+        ? ''
+        : first.text;
+    return `.${step.name}(${text.length > 24 || text.includes('\n') ? '' : text})`;
+}
+function isTextual(field) {
+    return ((field.type === 'string' || field.type === 'text') &&
+        field.enumName === undefined &&
+        field.arrayDepth === 0 &&
+        field.relation === undefined);
+}
+const TYPE_LABELS = {
+    text: 'string',
+    string: 'string',
+    uuid: 'string',
+    int: 'number',
+    float: 'number',
+    bigInt: 'bigint',
+    boolean: 'boolean',
+    date: 'Date',
+    dateTime: 'Date',
+    json: 'unknown',
+};
+/** A short name for a resolved type, used when a union of unlike types falls back to json. */
+function describeField(field) {
+    const base = field.relation !== undefined
+        ? field.relation.model
+        : (field.enumName ?? TYPE_LABELS[field.type] ?? field.type);
+    return `${base}${'[]'.repeat(field.arrayDepth)}`;
+}
+function sameShape(first, second) {
+    return (first.type === second.type &&
+        first.enumName === second.enumName &&
+        first.arrayDepth === second.arrayDepth &&
+        first.relation?.model === second.relation?.model &&
+        first.relation?.many === second.relation?.many);
+}
+function mergeNotes(target, source) {
+    target.dropped.push(...source.dropped);
+    target.problems.push(...source.problems);
+}
+/** Resolves the Zod expression at `node` (a property value). */
+export function resolveFieldNode(scope, node) {
+    return resolveNode(scope, node, 0);
+}
+function resolveNode(scope, node, depth) {
+    const chain = unwindChain(scope.file, node);
+    if (chain === undefined) {
+        return jsonField(`the value \`${truncate(node.text)}\` is not a Zod schema this reader understands; it was kept as json.`);
+    }
+    return resolveChain(scope, chain, depth);
+}
+function truncate(text) {
+    const flat = text.replace(/\s+/g, ' ');
+    return flat.length > 60 ? `${flat.slice(0, 57)}...` : flat;
+}
+export function resolveChain(scope, chain, depth) {
+    if (depth > MAX_DEPTH) {
+        return jsonField('the schema is nested too deeply; it was kept as json.');
+    }
+    let field = chain.base === undefined
+        ? resolveReference(scope, chain.ref ?? '', depth)
+        : resolveBase(scope, chain.base.name, chain.base.args, depth);
+    for (const step of chain.steps) {
+        field = applyStep(scope, field, step, depth);
+    }
+    return field;
+}
+function resolveReference(scope, name, depth) {
+    const { host } = scope;
+    switch (host.kindOf(name)) {
+        case 'model': {
+            const field = emptyField('json');
+            field.relation = { model: host.modelNameOf(name) ?? name, many: false };
+            return field;
+        }
+        case 'enum': {
+            const field = emptyField('string');
+            const enumName = host.enumNameOf(name);
+            if (enumName === undefined) {
+                return jsonField(`the enum "${name}" could not be read; kept as json.`);
+            }
+            field.enumName = enumName;
+            return field;
+        }
+        case 'alias': {
+            const alias = host.aliasOf(name);
+            if (alias === undefined) {
+                return jsonField(`"${name}" could not be read; it was kept as json.`);
+            }
+            return resolveNode({ ...scope, file: alias.file }, alias.node, depth + 1);
+        }
+        case 'values':
+            return jsonField(`"${name}" is a list of values, not a Zod schema; it was kept as json.`);
+        default:
+            return jsonField(`"${name}" is not declared in the input files, so its type is unknown; it was kept as json. Pass the file that declares it too.`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+function resolveBase(scope, name, args, depth) {
+    const first = args[0];
+    switch (name) {
+        case 'string':
+        case 'coerce.string':
+        case 'templateLiteral':
+            return emptyField('text');
+        case 'number':
+        case 'coerce.number':
+        case 'float32':
+        case 'float64':
+            return emptyField('float');
+        case 'int':
+        case 'int32':
+        case 'uint32':
+            return emptyField('int');
+        case 'bigint':
+        case 'coerce.bigint':
+        case 'int64':
+        case 'uint64':
+            return emptyField('bigInt');
+        case 'boolean':
+        case 'coerce.boolean':
+        case 'stringbool':
+            return emptyField('boolean');
+        case 'date':
+        case 'coerce.date':
+            return emptyField('dateTime');
+        case 'file':
+            return emptyField('bytes');
+        case 'null': {
+            const field = jsonField();
+            field.onlyNull = true;
+            field.nullable = true;
+            return field;
+        }
+        case 'undefined': {
+            const field = jsonField();
+            field.onlyUndefined = true;
+            field.optional = true;
+            return field;
+        }
+        case 'enum':
+        case 'nativeEnum':
+            return resolveEnum(scope, name, first);
+        case 'literal':
+            return resolveLiteral(scope, first);
+        case 'array':
+        case 'set':
+            return wrapArray(first === undefined
+                ? jsonField(`z.${name}() has no element schema; kept as json.`)
+                : resolveNode(scope, first, depth + 1));
+        case 'union':
+        case 'xor':
+            return resolveUnion(scope, first, depth);
+        case 'preprocess':
+            return withDropped(args[1] === undefined
+                ? jsonField('z.preprocess() has no schema; kept as json.')
+                : resolveNode(scope, args[1], depth + 1), '.preprocess()');
+        case 'pipe':
+            return withDropped(first === undefined
+                ? jsonField('z.pipe() has no schema; kept as json.')
+                : resolveNode(scope, first, depth + 1), '.pipe()');
+        default:
+            break;
+    }
+    if (name in STRING_FORMAT_BASES) {
+        return stringFormat(name, STRING_FORMAT_BASES[name] ?? 'plain', true);
+    }
+    if (WRAPPER_BASES.has(name)) {
+        return resolveWrapper(scope, name, args, depth);
+    }
+    if (JSON_BASES.has(name)) {
+        return emptyField('json');
+    }
+    if (OBJECT_BASES.has(name)) {
+        return jsonField('a nested z.object() is kept as one json column (no model is made for an unnamed object).');
+    }
+    if (name === 'tuple') {
+        return jsonField('a z.tuple() is kept as one json column.');
+    }
+    if (name === 'intersection') {
+        return jsonField('a z.intersection() is kept as one json column.');
+    }
+    if (name === 'discriminatedUnion') {
+        return jsonField('a z.discriminatedUnion() is kept as one json column.');
+    }
+    if (NO_COLUMN_BASES.has(name)) {
+        return jsonField(`z.${name}() has no column type; it was kept as json.`);
+    }
+    return jsonField(`z.${name}() is not a Zod constructor this reader knows; it was kept as json.`);
+}
+function withDropped(field, text) {
+    field.dropped.push(text);
+    return field;
+}
+function stringFormat(name, target, asConstructor) {
+    const field = emptyField(target === 'plain' ? 'text' : target);
+    if (target === 'plain') {
+        field.dropped.push(asConstructor ? `z.${name}()` : `.${name}()`);
+    }
+    return field;
+}
+function resolveWrapper(scope, name, args, depth) {
+    const first = args[0];
+    if (first === undefined) {
+        return jsonField(`z.${name}() has no schema; kept as json.`);
+    }
+    if (name === 'lazy' && isFunctionNode(first)) {
+        const inner = functionResult(first);
+        return inner === undefined
+            ? jsonField('z.lazy() returns something other than one schema; kept as json.')
+            : resolveNode(scope, inner, depth + 1);
+    }
+    return applyStep(scope, resolveNode(scope, first, depth + 1), { name, args: args.slice(1) }, depth);
+}
+function resolveEnum(scope, name, argument) {
+    if (argument === undefined) {
+        return jsonField(`z.${name}() has no values; kept as json.`);
+    }
+    const source = stripWrappers(argument);
+    let enumValues;
+    if (source.type === 'array') {
+        const values = [];
+        for (const item of source.namedChildren) {
+            const literal = literalOf(item);
+            if (typeof literal === 'string') {
+                values.push({ name: literal, dbValue: literal });
+            }
+            else if (item.type !== 'comment') {
+                return jsonField(`z.${name}() lists a value that is not a string literal; kept as json.`);
+            }
+        }
+        enumValues = { values, numeric: false };
+    }
+    else if (source.type === 'object') {
+        enumValues = objectEnumValues(source);
+    }
+    else if (source.type === 'identifier') {
+        enumValues = scope.host.valuesOf(source.text);
+        if (enumValues === undefined) {
+            return jsonField(`z.${name}(${source.text}) refers to a list of values that is not declared in the input files; kept as json.`);
+        }
+    }
+    if (enumValues?.numeric === true) {
+        const field = emptyField('int');
+        field.dropped.push(`numeric enum z.${name}(${truncate(argument.text)})`);
+        return field;
+    }
+    if (enumValues === undefined || enumValues.values.length === 0) {
+        return jsonField(`z.${name}(${truncate(argument.text)}) has values that could not be read statically; kept as json.`);
+    }
+    const field = emptyField('string');
+    field.enumName = scope.host.inlineEnum(scope.model, scope.key, enumValues.values);
+    return field;
+}
+/** Reads `{ A: 'a', B: 'b' }` as enum members (name -> stored value). */
+export function objectEnumValues(objectNode) {
+    const values = [];
+    let numeric = false;
+    for (const member of objectMembers(objectNode).members) {
+        if (member.kind !== 'property') {
+            continue;
+        }
+        const literal = literalOf(member.node);
+        if (typeof literal === 'string') {
+            values.push({ name: member.key, dbValue: literal });
+        }
+        else if (typeof literal === 'number') {
+            numeric = true;
+        }
+    }
+    return { values: numeric ? [] : values, numeric };
+}
+function resolveLiteral(scope, argument) {
+    const text = argument === undefined ? '' : truncate(argument.text);
+    if (argument === undefined) {
+        return jsonField('z.literal() has no value; kept as json.');
+    }
+    if (stripWrappers(argument).type === 'array') {
+        // Zod 4: z.literal(['a', 'b']) is a union of literals.
+        const items = stripWrappers(argument).namedChildren.filter((child) => child.type !== 'comment');
+        return combineOptions(scope, items.map((item) => resolveLiteral(scope, item)));
+    }
+    const literal = literalOf(argument);
+    let field;
+    if (typeof literal === 'string') {
+        field = emptyField('text');
+        field.literalString = literal;
+    }
+    else if (typeof literal === 'number') {
+        field = emptyField(Number.isInteger(literal) ? 'int' : 'float');
+    }
+    else if (typeof literal === 'boolean') {
+        field = emptyField('boolean');
+    }
+    else if (literal === null) {
+        field = jsonField();
+        field.onlyNull = true;
+        return field;
+    }
+    else {
+        return jsonField(`z.literal(${text}) is not a plain literal; kept as json.`);
+    }
+    field.dropped.push(`z.literal(${text})`);
+    return field;
+}
+function wrapArray(inner) {
+    const field = inner;
+    if (inner.optional || inner.nullable) {
+        field.dropped.push('nullable array elements');
+        field.optional = false;
+        field.nullable = false;
+    }
+    field.hasDefault = false;
+    delete field.default;
+    if (field.relation !== undefined) {
+        field.relation = { ...field.relation, many: true };
+    }
+    else {
+        field.arrayDepth += 1;
+    }
+    return field;
+}
+function resolveUnion(scope, options, depth) {
+    const list = options === undefined ? undefined : stripWrappers(options);
+    if (list === undefined || list.type !== 'array') {
+        return jsonField('a z.union() without an inline list of schemas is kept as json.');
+    }
+    const resolved = list.namedChildren
+        .filter((child) => child.type !== 'comment')
+        .map((child) => resolveNode(scope, child, depth + 1));
+    return combineOptions(scope, resolved);
+}
+/** Merges the options of a union: nulls make it nullable, string literals make an enum, equal types collapse. */
+function combineOptions(scope, options) {
+    const nullable = options.some((option) => option.onlyNull === true);
+    const optional = options.some((option) => option.onlyUndefined === true);
+    const rest = options.filter((option) => option.onlyNull !== true && option.onlyUndefined !== true);
+    let result;
+    const first = rest[0];
+    if (first === undefined) {
+        result = jsonField();
+    }
+    else if (rest.length === 1) {
+        result = first;
+    }
+    else if (rest.every((option) => option.literalString !== undefined)) {
+        result = emptyField('string');
+        result.enumName = scope.host.inlineEnum(scope.model, scope.key, rest.map((option) => ({
+            name: option.literalString ?? '',
+            dbValue: option.literalString ?? '',
+        })));
+    }
+    else if (rest.every((option) => sameShape(first, option))) {
+        result = first;
+        for (const option of rest.slice(1)) {
+            mergeNotes(result, option);
+            if (option.maxLength !== result.maxLength) {
+                delete result.maxLength;
+            }
+        }
+    }
+    else {
+        result = jsonField(`a union of unlike types (${rest.map(describeField).join(' | ')}) is kept as one json column.`);
+        for (const option of rest) {
+            result.dropped.push(...option.dropped);
+        }
+    }
+    if (nullable) {
+        result.nullable = true;
+    }
+    if (optional) {
+        result.optional = true;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Steps
+// ---------------------------------------------------------------------------
+function numberArgument(step) {
+    const first = step.args[0];
+    const literal = first === undefined ? undefined : literalOf(first);
+    return typeof literal === 'number' ? literal : undefined;
+}
+function applyStep(scope, field, step, depth) {
+    switch (step.name) {
+        case 'optional':
+            field.optional = true;
+            return field;
+        case 'nullable':
+            field.nullable = true;
+            return field;
+        case 'nullish':
+            field.optional = true;
+            field.nullable = true;
+            return field;
+        case 'nonoptional':
+        case 'required':
+            field.optional = false;
+            return field;
+        case 'default':
+        case 'prefault':
+        case 'catch':
+            applyDefault(scope, field, step);
+            return field;
+        case 'array':
+            return wrapArray(field);
+        case 'or':
+            return applyUnion(scope, field, step, depth);
+        case 'and':
+            field.problems.push('a .and() intersection is kept as one json column.');
+            field.type = 'json';
+            delete field.maxLength;
+            delete field.enumName;
+            delete field.relation;
+            field.arrayDepth = 0;
+            return field;
+        case 'int':
+            if (field.type === 'float' && field.arrayDepth === 0) {
+                field.type = 'int';
+            }
+            return field;
+        case 'max':
+        case 'length': {
+            const limit = numberArgument(step);
+            if (isTextual(field) && limit !== undefined) {
+                field.maxLength = limit;
+                if (step.name === 'length') {
+                    field.dropped.push(`${stepText(step)} (kept as the maximum length)`);
+                }
+                return field;
+            }
+            field.dropped.push(stepText(step));
+            return field;
+        }
+        case 'regex':
+            applyRegex(field, step);
+            return field;
+        default:
+            break;
+    }
+    if (isTextual(field) && step.name in STRING_FORMAT_STEPS) {
+        const target = STRING_FORMAT_STEPS[step.name] ?? 'plain';
+        if (target === 'plain') {
+            field.dropped.push(stepText(step));
+        }
+        else {
+            field.type = target;
+            delete field.maxLength;
+        }
+        return field;
+    }
+    if (!SILENT_STEPS.has(step.name)) {
+        field.dropped.push(stepText(step));
+    }
+    return field;
+}
+function applyRegex(field, step) {
+    const pattern = step.args[0]?.text ?? '';
+    if (isTextual(field) && field.maxLength === undefined) {
+        if (pattern === BIGINT_PATTERN) {
+            field.type = 'bigInt';
+            return;
+        }
+        if (pattern === DECIMAL_UNSIZED) {
+            field.type = 'decimal';
+            return;
+        }
+        const sized = DECIMAL_SIZED.exec(pattern);
+        if (sized !== null) {
+            const integerDigits = Number(sized[1]);
+            const places = sized[2] === undefined ? 0 : Number(sized[2]);
+            field.type = 'decimal';
+            field.maxDigits = integerDigits + places;
+            field.decimalPlaces = places;
+            return;
+        }
+    }
+    field.dropped.push('.regex()');
+}
+function applyUnion(scope, field, step, depth) {
+    const other = step.args[0];
+    return other === undefined
+        ? field
+        : combineOptions(scope, [field, resolveNode(scope, other, depth + 1)]);
+}
+function applyDefault(scope, field, step) {
+    field.hasDefault = true;
+    if (step.name === 'catch') {
+        field.dropped.push('.catch() (read as the default)');
+    }
+    const argument = step.args[0];
+    if (argument === undefined) {
+        return;
+    }
+    const value = defaultOf(scope, field, argument);
+    if (value === 'none') {
+        return;
+    }
+    if (value === undefined) {
+        field.dropped.push(stepText({ name: 'default', args: step.args }));
+        return;
+    }
+    field.default = value;
+}
+/** Reads a default value; undefined when it is not a value the shared model can store, "none" for a null default. */
+function defaultOf(scope, field, argument) {
+    const current = stripWrappers(argument);
+    if (isFunctionNode(current)) {
+        const result = functionResult(current);
+        const text = result?.text.replace(/\s+/g, '') ?? '';
+        if ((field.type === 'dateTime' || field.type === 'date') &&
+            /^(newDate\(\)|Date\.now\(\))$/.test(text)) {
+            return { kind: 'now' };
+        }
+        if (field.type === 'uuid' && /randomUUID\(\)$/.test(text)) {
+            return { kind: 'uuid' };
+        }
+        return result !== undefined && field.arrayDepth === 0
+            ? structuredDefault(field, result)
+            : undefined;
+    }
+    const literal = literalOf(current);
+    if (literal === null) {
+        return 'none';
+    }
+    if (typeof literal === 'string' && field.enumName !== undefined) {
+        const member = scope.host.enumMemberName(field.enumName, literal);
+        return member === undefined
+            ? undefined
+            : { kind: 'enumValue', value: member };
+    }
+    if (literal !== undefined) {
+        return field.arrayDepth === 0
+            ? { kind: 'literal', value: literal }
+            : undefined;
+    }
+    return field.arrayDepth === 0 ? structuredDefault(field, current) : undefined;
+}
+/** `{}` and `[]` as the default of a json column are stored as their text. */
+function structuredDefault(field, node) {
+    const current = stripWrappers(node);
+    if (field.type !== 'json') {
+        return undefined;
+    }
+    if (current.type === 'object' && current.namedChildCount === 0) {
+        return { kind: 'literal', value: '{}' };
+    }
+    if (current.type === 'array' && current.namedChildCount === 0) {
+        return { kind: 'literal', value: '[]' };
+    }
+    return undefined;
+}
+//# sourceMappingURL=zodFields.js.map