@supatype/cli 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/type-extractor.js

@@ -0,0 +1,1213 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import ts from "typescript";
+import { applyImportRename, createResolveContext, needsChecker, resolveTypeNode, tryResolveTypeReference, unknownTypeError, } from "./type-resolver.js";
+import { emitField, emitModel, emitSchema, defaultPgTypeForKind, scalar, } from "./schema-ast-v2.js";
+export function extractSchemaAstFromTypes(schemaPath, cwd = process.cwd()) {
+    const absPath = resolve(cwd, schemaPath);
+    if (!existsSync(absPath)) {
+        throw new Error(`Schema file not found: ${absPath}`);
+    }
+    const sourceFiles = loadSchemaSourceFiles(absPath);
+    const resolveCtx = createResolveContext(sourceFiles);
+    const bucketAliases = new Map();
+    const bucketsById = new Map();
+    for (const sourceFile of sourceFiles) {
+        const bucketContext = collectBucketContext(sourceFile);
+        for (const [alias, bucketId] of bucketContext.aliases) {
+            bucketAliases.set(alias, bucketId);
+        }
+        for (const [bucketId, bucket] of bucketContext.bucketsById) {
+            const existing = bucketsById.get(bucketId);
+            if (existing !== undefined && !bucketsEqual(existing, bucket)) {
+                throw new Error(`Conflicting Bucket<> declarations for id "${bucketId}". Use a single export per bucket id.`);
+            }
+            bucketsById.set(bucketId, bucket);
+        }
+    }
+    const blockAliases = new Map();
+    for (const sourceFile of sourceFiles) {
+        const next = collectBlockAliases(sourceFile, bucketAliases, bucketsById, resolveCtx);
+        for (const [name, block] of next) {
+            blockAliases.set(name, block);
+        }
+    }
+    const models = [];
+    for (const sourceFile of sourceFiles) {
+        for (const stmt of sourceFile.statements) {
+            if (!ts.isTypeAliasDeclaration(stmt))
+                continue;
+            if (!hasExportModifier(stmt))
+                continue;
+            if (!ts.isTypeReferenceNode(stmt.type))
+                continue;
+            const modelTypeName = stmt.type.typeName.getText(sourceFile);
+            if (modelTypeName !== "Model" && modelTypeName !== "LocalizedModel")
+                continue;
+            const [fieldsArg, metaArg] = stmt.type.typeArguments ?? [];
+            if (!fieldsArg)
+                continue;
+            const fieldsLiteral = unwrapModelFields(fieldsArg, sourceFile, resolveCtx);
+            if (!fieldsLiteral)
+                continue;
+            const metaHints = parseMetaLiteral(metaArg, sourceFile);
+            const fieldContext = {
+                autoLocalize: modelTypeName === "LocalizedModel" || metaHints.autoLocalize === true,
+            };
+            const fields = {};
+            for (const member of fieldsLiteral.members) {
+                if (!ts.isPropertySignature(member) || !member.type)
+                    continue;
+                const name = getPropertyName(member.name);
+                if (!name)
+                    continue;
+                fields[name] = parseFieldType(name, member.type, sourceFile, blockAliases, bucketAliases, bucketsById, fieldContext, resolveCtx);
+            }
+            const { tableName, access, options } = parseModelMeta(metaArg, sourceFile, stmt.name.text, fieldsArg, fields);
+            models.push(emitModel(stmt.name.text, fields, options, tableName, access));
+        }
+    }
+    if (models.length === 0)
+        return null;
+    const storageBuckets = bucketsById.size > 0 ? [...bucketsById.values()].sort((a, b) => a.id.localeCompare(b.id)) : undefined;
+    let localeConfig;
+    for (const sourceFile of sourceFiles) {
+        const found = collectLocaleConfig(sourceFile);
+        if (!found)
+            continue;
+        if (localeConfig !== undefined) {
+            throw new Error("Conflicting LocaleConfig declarations. Export at most one `localeConfig` type alias.");
+        }
+        localeConfig = found;
+    }
+    return emitSchema(models, {
+        ...(storageBuckets !== undefined && storageBuckets.length > 0 && { storageBuckets }),
+        ...(localeConfig !== undefined && {
+            locales: localeConfig.locales,
+            defaultLocale: localeConfig.defaultLocale,
+        }),
+    });
+}
+function loadSchemaSourceFiles(entryPath) {
+    const visited = new Set();
+    const sourceFiles = [];
+    const queue = [entryPath];
+    while (queue.length > 0) {
+        const currentPath = queue.shift();
+        if (!currentPath)
+            continue;
+        if (visited.has(currentPath))
+            continue;
+        visited.add(currentPath);
+        if (!existsSync(currentPath))
+            continue;
+        const sourceText = readFileSync(currentPath, "utf8");
+        const sourceFile = ts.createSourceFile(currentPath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        sourceFiles.push(sourceFile);
+        const baseDir = dirname(currentPath);
+        for (const stmt of sourceFile.statements) {
+            let specifier;
+            if (ts.isExportDeclaration(stmt)) {
+                if (!stmt.moduleSpecifier || !ts.isStringLiteral(stmt.moduleSpecifier))
+                    continue;
+                specifier = stmt.moduleSpecifier.text;
+            }
+            else if (ts.isImportDeclaration(stmt)) {
+                if (!stmt.moduleSpecifier || !ts.isStringLiteral(stmt.moduleSpecifier))
+                    continue;
+                specifier = stmt.moduleSpecifier.text;
+            }
+            else {
+                continue;
+            }
+            if (!specifier.startsWith("."))
+                continue;
+            const nextPath = resolveTypeModulePath(baseDir, specifier);
+            if (!nextPath)
+                continue;
+            if (!visited.has(nextPath))
+                queue.push(nextPath);
+        }
+    }
+    return sourceFiles;
+}
+function resolveTypeModulePath(fromDir, specifier) {
+    const basePath = isAbsolute(specifier) ? specifier : resolve(fromDir, specifier);
+    const candidates = specifier.endsWith(".js")
+        ? [
+            basePath,
+            basePath.replace(/\.js$/i, ".ts"),
+            basePath.replace(/\.js$/i, ".tsx"),
+            basePath.replace(/\.js$/i, ".d.ts"),
+        ]
+        : [
+            basePath,
+            `${basePath}.ts`,
+            `${basePath}.tsx`,
+            `${basePath}.d.ts`,
+            resolve(basePath, "index.ts"),
+            resolve(basePath, "index.tsx"),
+            resolve(basePath, "index.d.ts"),
+        ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function hasExportModifier(node) {
+    if (!ts.canHaveModifiers(node))
+        return false;
+    return (ts.getModifiers(node)?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword) ?? false);
+}
+function getPropertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+        return name.text;
+    return null;
+}
+function unwrapModelFields(typeNode, sourceFile, resolveCtx, depth = 0) {
+    if (depth > 16)
+        return null;
+    if (ts.isTypeLiteralNode(typeNode))
+        return typeNode;
+    if (needsChecker(typeNode)) {
+        const resolved = resolveTypeNode(typeNode, sourceFile, resolveCtx);
+        if (ts.isTypeLiteralNode(resolved))
+            return resolved;
+        return unwrapModelFields(resolved, sourceFile, resolveCtx, depth + 1);
+    }
+    if (!ts.isTypeReferenceNode(typeNode) || !ts.isIdentifier(typeNode.typeName))
+        return null;
+    const typeName = applyImportRename(typeNode.typeName.text, sourceFile, resolveCtx.renameMap);
+    // Composite helpers in @supatype/types wrap the concrete field object.
+    if (typeName === "WithTimestamps" ||
+        typeName === "WithSoftDelete" ||
+        typeName === "WithPublishable") {
+        const inner = typeNode.typeArguments?.[0];
+        if (!inner)
+            return null;
+        return unwrapModelFields(inner, sourceFile, resolveCtx, depth + 1);
+    }
+    const expanded = tryResolveTypeReference(typeNode, sourceFile, resolveCtx);
+    if (expanded) {
+        if (ts.isTypeLiteralNode(expanded))
+            return expanded;
+        return unwrapModelFields(expanded, sourceFile, resolveCtx, depth + 1);
+    }
+    return null;
+}
+/** Parse `Default<T, V>` second type argument into a JSON-serializable literal. */
+function parseDefaultLiteral(node, sourceFile) {
+    if (ts.isLiteralTypeNode(node)) {
+        const lit = node.literal;
+        if (ts.isStringLiteral(lit) || ts.isNoSubstitutionTemplateLiteral(lit))
+            return lit.text;
+        if (ts.isNumericLiteral(lit))
+            return Number(lit.text);
+        if (lit.kind === ts.SyntaxKind.TrueKeyword)
+            return true;
+        if (lit.kind === ts.SyntaxKind.FalseKeyword)
+            return false;
+        if (lit.kind === ts.SyntaxKind.NullKeyword)
+            return null;
+    }
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return true;
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return false;
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+        return null;
+    // Negative numeric literals appear as PrefixUnaryExpression in some TS versions.
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken) {
+        const inner = parseDefaultLiteral(node.operand, sourceFile);
+        if (typeof inner === "number")
+            return -inner;
+    }
+    return undefined;
+}
+function parseFieldType(fieldName, typeNode, sourceFile, blockAliases, bucketAliases, bucketsById, context = {}, resolveCtx) {
+    const flags = {
+        required: true,
+        unique: false,
+        index: false,
+        primaryKey: false,
+        serverGenerated: false,
+        autoIncrement: false,
+        relationCardinality: undefined,
+        relationTarget: undefined,
+        editorReadOnly: false,
+        computedFromSources: undefined,
+        computedFromTemplate: undefined,
+        fieldDefault: undefined,
+        localized: false,
+        notLocalized: false,
+    };
+    const resolving = new Set();
+    let current = typeNode;
+    while (ts.isTypeReferenceNode(current) && ts.isIdentifier(current.typeName)) {
+        const typeName = applyImportRename(current.typeName.text, sourceFile, resolveCtx.renameMap);
+        switch (typeName) {
+            case "Optional":
+                flags.required = false;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "Unique":
+                flags.unique = true;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "Indexed":
+                flags.index = true;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "ServerDefault":
+                flags.serverGenerated = true;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "AutoIncrement":
+                flags.serverGenerated = true;
+                flags.autoIncrement = true;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "PrimaryKey":
+                flags.primaryKey = true;
+                flags.required = true;
+                flags.unique = true;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "Default": {
+                const valueArg = current.typeArguments?.[1];
+                if (valueArg !== undefined) {
+                    const literal = parseDefaultLiteral(valueArg, sourceFile);
+                    if (literal !== undefined) {
+                        flags.fieldDefault = literal;
+                    }
+                }
+                // Unwrap to T so `Default<boolean, true>` resolves as boolean, not text.
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            }
+            case "Searchable":
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "EditorReadOnly":
+                flags.editorReadOnly = true;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "Computed":
+                flags.editorReadOnly = true;
+                flags.serverGenerated = true;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "ComputedFrom": {
+                const valueArg = current.typeArguments?.[0];
+                const sourcesArg = current.typeArguments?.[1];
+                const parsed = parseComputedFromSecondArg(sourcesArg, sourceFile);
+                if (parsed) {
+                    flags.computedFromSources = parsed.sources;
+                    flags.computedFromTemplate = parsed.template;
+                }
+                else {
+                    flags.computedFromSources = ["title"];
+                }
+                current = valueArg ?? current;
+                continue;
+            }
+            case "MaxLength":
+            case "MinLength":
+            case "Between":
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "Localized":
+                flags.localized = true;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "NotLocalized":
+                flags.notLocalized = true;
+                current = current.typeArguments?.[0] ?? current;
+                continue;
+            case "RelatedTo":
+                flags.relationCardinality = "one";
+                flags.relationTarget = relationTargetFromTypeArg(current.typeArguments?.[0], sourceFile);
+                // `target` must match `ModelAst.name` to satisfy validator resolution.
+                // FK column follows the field name (two relations to the same model need distinct columns).
+                return emitField({
+                    kind: "relation",
+                    kernel: { cardinality: "belongsTo", target: flags.relationTarget },
+                    db: { foreignKey: relationForeignKeyFromField(fieldName) },
+                    platform: flags.editorReadOnly ? { readOnly: true } : {},
+                });
+            case "HasOne":
+                flags.relationCardinality = "one";
+                flags.relationTarget = current.typeArguments?.[0]?.getText(sourceFile).replace(/\W/g, "") ?? "unknown";
+                return emitField({
+                    kind: "relation",
+                    kernel: { cardinality: "hasOne", target: flags.relationTarget },
+                    db: {},
+                    platform: flags.editorReadOnly ? { readOnly: true } : {},
+                });
+            case "HasMany":
+            case "ManyToMany":
+                flags.relationCardinality = "many";
+                flags.relationTarget = current.typeArguments?.[0]?.getText(sourceFile).replace(/\W/g, "") ?? "unknown";
+                return emitField({
+                    kind: "relation",
+                    kernel: { cardinality: "hasMany", target: flags.relationTarget },
+                    db: {},
+                    platform: flags.editorReadOnly ? { readOnly: true } : {},
+                });
+            default: {
+                const resolved = tryResolveTypeReference(current, sourceFile, resolveCtx, { fieldName, resolving });
+                if (resolved) {
+                    current = resolved;
+                    continue;
+                }
+                break;
+            }
+        }
+        break;
+    }
+    const scalarBase = parseScalarType(current, sourceFile, blockAliases, bucketAliases, bucketsById, context, resolveCtx, fieldName, resolving);
+    let parsed = {
+        kind: scalarBase.kind,
+        kernel: {
+            ...scalarBase.kernel,
+            required: flags.required,
+            ...(flags.primaryKey && { primaryKey: true }),
+        },
+        db: {
+            ...scalarBase.db,
+            unique: flags.unique,
+            index: flags.index,
+        },
+        platform: {
+            ...scalarBase.platform,
+            ...(flags.editorReadOnly && { readOnly: true }),
+        },
+    };
+    if (flags.autoIncrement && parsed.kind === "integer") {
+        parsed = { ...parsed, kind: "serial", db: { ...parsed.db, pgType: "SERIAL" } };
+    }
+    if (fieldName === "id" && parsed.kind === "uuid" && flags.primaryKey === false) {
+        parsed = {
+            ...parsed,
+            kernel: { ...parsed.kernel, primaryKey: true, required: true },
+            db: { ...parsed.db, unique: true },
+        };
+    }
+    if (flags.fieldDefault !== undefined) {
+        if (parsed.kernel.default !== undefined) {
+            throw new Error(`Field "${fieldName}": use either Default<…> or an inline type default (e.g. RichText<"…">), not both.`);
+        }
+        parsed = {
+            ...parsed,
+            kernel: { ...parsed.kernel, default: { kind: "value", value: flags.fieldDefault } },
+        };
+    }
+    if (parsed.kernel.primaryKey === true && parsed.kind === "uuid" && parsed.kernel.default === undefined) {
+        parsed = {
+            ...parsed,
+            kernel: { ...parsed.kernel, default: { kind: "genRandomUuid" } },
+        };
+    }
+    else if (parsed.kernel.primaryKey === true &&
+        (parsed.kind === "serial" || parsed.kind === "bigSerial")) {
+        flags.serverGenerated = true;
+    }
+    if (flags.serverGenerated === true) {
+        parsed = { ...parsed, db: { ...parsed.db, serverGenerated: true } };
+    }
+    const auditTs = fieldName === "created_at" ||
+        fieldName === "updated_at" ||
+        fieldName === "createdAt" ||
+        fieldName === "updatedAt";
+    if (auditTs) {
+        parsed = { ...parsed, db: { ...parsed.db, serverGenerated: true } };
+        if ((parsed.kind === "datetime" || parsed.kind === "date") &&
+            parsed.kernel.default === undefined) {
+            parsed = { ...parsed, kernel: { ...parsed.kernel, default: { kind: "now" } } };
+        }
+    }
+    if (flags.serverGenerated &&
+        (parsed.kind === "datetime" || parsed.kind === "date") &&
+        parsed.kernel.default === undefined) {
+        parsed = { ...parsed, kernel: { ...parsed.kernel, default: { kind: "now" } } };
+    }
+    const hasCfTemplate = flags.computedFromTemplate !== undefined;
+    const hasCfSources = Boolean(flags.computedFromSources && flags.computedFromSources.length > 0);
+    if (parsed.kind === "text" && (hasCfTemplate || hasCfSources)) {
+        const kernel = { ...parsed.kernel };
+        if (hasCfSources && flags.computedFromSources) {
+            kernel.sources = flags.computedFromSources;
+        }
+        if (hasCfTemplate && flags.computedFromTemplate !== undefined) {
+            kernel.template = flags.computedFromTemplate;
+        }
+        parsed = { ...parsed, kernel };
+    }
+    return emitField(finalizeParsedField(parsed, flags, context));
+}
+function finalizeParsedField(parsed, flags, context) {
+    let localized = flags.localized;
+    if (!localized &&
+        !flags.notLocalized &&
+        context.autoLocalize &&
+        shouldAutoLocalizeFieldKind(parsed.kind)) {
+        localized = true;
+    }
+    if (parsed.kind === "blocks" && parsed.kernel.blocks && context.autoLocalize && !localized) {
+        return {
+            ...parsed,
+            kernel: {
+                ...parsed.kernel,
+                blocks: parsed.kernel.blocks.map((blockDef) => ({
+                    ...blockDef,
+                    fields: Object.fromEntries(Object.entries(blockDef.fields).map(([name, fieldWire]) => [
+                        name,
+                        localizeFieldWire(fieldWire),
+                    ])),
+                })),
+            },
+        };
+    }
+    if (localized) {
+        return {
+            ...parsed,
+            kernel: { ...parsed.kernel, localized: true },
+            db: { ...parsed.db, pgType: "JSONB" },
+        };
+    }
+    return parsed;
+}
+function shouldAutoLocalizeFieldKind(kind) {
+    return kind === "text" || kind === "richText";
+}
+function localizeFieldWire(field) {
+    if (field.localized === true)
+        return field;
+    if (!shouldAutoLocalizeFieldKind(field.kind))
+        return field;
+    const annotations = (field.annotations ?? {});
+    return {
+        ...field,
+        localized: true,
+        annotations: {
+            ...annotations,
+            db: { ...annotations.db, pgType: "JSONB" },
+        },
+    };
+}
+function parseScalarType(typeNode, sourceFile, blockAliases, bucketAliases, bucketsById, context = {}, resolveCtx, fieldName = "?", resolving = new Set()) {
+    if (ts.isArrayTypeNode(typeNode)) {
+        const element = parseScalarType(typeNode.elementType, sourceFile, blockAliases, bucketAliases, bucketsById, context, resolveCtx, fieldName, resolving);
+        return scalar("array", {
+            db: { elementType: defaultPgTypeForKind(element.kind) },
+        });
+    }
+    if (ts.isUnionTypeNode(typeNode)) {
+        const literals = typeNode.types.filter(ts.isLiteralTypeNode);
+        if (literals.length === typeNode.types.length && literals.every((lit) => ts.isStringLiteral(lit.literal))) {
+            return scalar("enum", {
+                kernel: {
+                    values: literals.map((lit) => lit.literal.text),
+                },
+            });
+        }
+        const nonNull = typeNode.types.find((t) => t.kind !== ts.SyntaxKind.NullKeyword);
+        if (nonNull) {
+            return parseScalarType(nonNull, sourceFile, blockAliases, bucketAliases, bucketsById, context, resolveCtx, fieldName, resolving);
+        }
+    }
+    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+        const resolved = tryResolveTypeReference(typeNode, sourceFile, resolveCtx, { fieldName, resolving });
+        if (resolved) {
+            return parseScalarType(resolved, sourceFile, blockAliases, bucketAliases, bucketsById, context, resolveCtx, fieldName, resolving);
+        }
+    }
+    if (ts.isTypeReferenceNode(typeNode)) {
+        const ref = ts.isIdentifier(typeNode.typeName)
+            ? applyImportRename(typeNode.typeName.text, sourceFile, resolveCtx.renameMap)
+            : typeNode.typeName.getText(sourceFile);
+        switch (ref) {
+            case "UUID":
+            case "SupatypeAuthUserId":
+                return scalar("uuid");
+            case "RichText": {
+                const defaultArg = typeNode.typeArguments?.[0];
+                if (!defaultArg)
+                    return scalar("richText");
+                const literal = parseDefaultLiteral(defaultArg, sourceFile);
+                if (literal === undefined) {
+                    throw new Error(`RichText default must be a string literal (plain text or Lexical JSON string), not HTML.`);
+                }
+                if (typeof literal !== "string") {
+                    throw new Error(`RichText<…> default must be a string literal (plain text or Lexical JSON string).`);
+                }
+                return scalar("richText", {
+                    kernel: { default: { kind: "value", value: literal } },
+                });
+            }
+            case "Slug": {
+                const fromArg = typeNode.typeArguments?.[0];
+                const fromLiteral = fromArg ? literalStringType(fromArg) : null;
+                return scalar("slug", { kernel: { from: fromLiteral ?? "title" } });
+            }
+            case "Email":
+                return scalar("email");
+            case "URL":
+                return scalar("url");
+            case "Markdown":
+            case "PhoneNumber":
+                return scalar("text");
+            case "Color":
+                return scalar("color");
+            case "IPAddress":
+                return scalar("ip");
+            case "CIDR":
+                return scalar("cidr");
+            case "MacAddress":
+                return scalar("macaddr");
+            case "XML":
+                return scalar("xml");
+            case "TSQuery":
+                return scalar("tsQuery");
+            case "TSVector":
+                return scalar("tsVector");
+            case "Money":
+                return scalar("money");
+            case "Decimal":
+                return scalar("decimal");
+            case "DateOnly":
+                return scalar("date");
+            case "Date":
+            case "DateTime":
+            case "Timestamp":
+                return scalar("datetime", { db: { pgType: "TIMESTAMP WITH TIME ZONE" } });
+            case "Int":
+                return scalar("integer");
+            case "SmallInt":
+                return scalar("smallInt");
+            case "BigInt":
+                return scalar("bigInt");
+            case "Float":
+                return scalar("float");
+            case "Bytea":
+                return scalar("bytes");
+            case "JSON":
+                return scalar("json");
+            case "Button":
+                return scalar("button", { db: { pgType: "JSONB" } });
+            case "Duration":
+                return scalar("json", { db: { pgType: "JSONB" } });
+            case "GeoPoint":
+            case "Geo":
+                return scalar("geo", { kernel: { geoType: "point", srid: 4326 } });
+            case "Asset":
+            case "FileAsset": {
+                const bucket = resolveBucketName(typeNode.typeArguments?.[0], sourceFile, bucketAliases, "assets");
+                const assetOpts = parseAssetFieldOptions(typeNode.typeArguments?.[1], sourceFile);
+                return attachStorageFieldMeta(scalar("file", {
+                    db: { pgType: "TEXT" },
+                    kernel: { bucket, ...(assetOpts.localized && { localized: true }) },
+                }), bucket, bucketsById);
+            }
+            case "ImageAsset": {
+                const bucket = resolveBucketName(typeNode.typeArguments?.[0], sourceFile, bucketAliases, "images");
+                const assetOpts = parseAssetFieldOptions(typeNode.typeArguments?.[1], sourceFile);
+                return attachStorageFieldMeta(scalar("image", {
+                    db: { pgType: "TEXT" },
+                    kernel: { bucket, ...(assetOpts.localized && { localized: true }) },
+                }), bucket, bucketsById);
+            }
+            case "Blocks":
+                return scalar("blocks", {
+                    kernel: {
+                        index: true,
+                        blocks: parseBlocksTypeDefinitions(typeNode.typeArguments?.[0], sourceFile, blockAliases, bucketAliases, bucketsById, context, resolveCtx),
+                    },
+                });
+            case "Vector": {
+                const dimensions = typeNode.typeArguments?.[0]?.getText(sourceFile);
+                return scalar("vector", {
+                    kernel: { dimensions: Number(dimensions ?? "1536") },
+                });
+            }
+            default:
+                throw unknownTypeError(ref, fieldName);
+        }
+    }
+    switch (typeNode.kind) {
+        case ts.SyntaxKind.StringKeyword:
+            return scalar("text");
+        case ts.SyntaxKind.NumberKeyword:
+            return scalar("float");
+        case ts.SyntaxKind.BooleanKeyword:
+            return scalar("boolean");
+        default:
+            return scalar("json");
+    }
+}
+function collectBlockAliases(sourceFile, bucketAliases, bucketsById, resolveCtx) {
+    const blocks = new Map();
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isTypeAliasDeclaration(stmt))
+            continue;
+        if (!ts.isTypeReferenceNode(stmt.type))
+            continue;
+        if (!ts.isIdentifier(stmt.type.typeName) || stmt.type.typeName.text !== "Block")
+            continue;
+        const block = parseInlineBlockDefinition(stmt.type, sourceFile, new Map(), bucketAliases, bucketsById, {}, resolveCtx);
+        if (!block)
+            continue;
+        blocks.set(stmt.name.text, block);
+    }
+    return blocks;
+}
+function collectLocaleConfig(sourceFile) {
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isTypeAliasDeclaration(stmt))
+            continue;
+        if (!hasExportModifier(stmt))
+            continue;
+        if (!ts.isTypeReferenceNode(stmt.type))
+            continue;
+        if (stmt.type.typeName.getText(sourceFile) !== "LocaleConfig")
+            continue;
+        const parsed = parseLocaleConfigTypeRef(stmt.type, sourceFile);
+        if (parsed)
+            return parsed;
+    }
+    return undefined;
+}
+function parseLocaleConfigTypeRef(typeRef, sourceFile) {
+    const [localesArg, defaultArg] = typeRef.typeArguments ?? [];
+    if (!localesArg || !defaultArg)
+        return null;
+    const locales = parseStringLiteralTuple(localesArg, sourceFile);
+    const defaultLocale = literalStringType(defaultArg);
+    if (!locales || locales.length === 0 || !defaultLocale)
+        return null;
+    if (!locales.includes(defaultLocale)) {
+        throw new Error(`LocaleConfig defaultLocale "${defaultLocale}" must be one of: ${locales.join(", ")}`);
+    }
+    return { locales, defaultLocale };
+}
+function parseStringLiteralTuple(node, sourceFile) {
+    if (!ts.isTupleTypeNode(node))
+        return null;
+    const out = [];
+    for (const el of node.elements) {
+        const lit = literalStringType(el);
+        if (!lit)
+            return null;
+        out.push(lit);
+    }
+    return out;
+}
+function collectBucketContext(sourceFile) {
+    const aliases = new Map();
+    const bucketsById = new Map();
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isTypeAliasDeclaration(stmt))
+            continue;
+        if (!ts.isTypeReferenceNode(stmt.type))
+            continue;
+        if (!ts.isIdentifier(stmt.type.typeName) || stmt.type.typeName.text !== "Bucket")
+            continue;
+        const [nameArg, configArg] = stmt.type.typeArguments ?? [];
+        if (!nameArg || !ts.isLiteralTypeNode(nameArg) || !ts.isStringLiteral(nameArg.literal))
+            continue;
+        const id = nameArg.literal.text;
+        aliases.set(stmt.name.text, id);
+        const parsed = configArg && ts.isTypeLiteralNode(configArg)
+            ? parseBucketTypeLiteral(configArg, sourceFile)
+            : {};
+        const next = buildExtractedBucketAst(id, parsed);
+        const existing = bucketsById.get(id);
+        if (existing !== undefined && !bucketsEqual(existing, next)) {
+            throw new Error(`Conflicting Bucket<> declarations for id "${id}". Use a single export per bucket id.`);
+        }
+        bucketsById.set(id, next);
+    }
+    return { aliases, bucketsById };
+}
+function buildExtractedBucketAst(id, parsed) {
+    const mode = parsed.accessMode ?? "private";
+    const pub = mode === "public";
+    const row = {
+        id,
+        public: pub,
+        accessMode: mode,
+        ...(parsed.allowedMimeTypes !== undefined && parsed.allowedMimeTypes.length > 0
+            ? { allowedMimeTypes: parsed.allowedMimeTypes }
+            : {}),
+        ...(parsed.fileSizeLimit !== undefined ? { fileSizeLimit: parsed.fileSizeLimit } : {}),
+        ...(parsed.access !== undefined &&
+            Object.keys(parsed.access).length > 0 && { access: parsed.access }),
+        ...(parsed.s3BucketPolicy !== undefined ? { s3BucketPolicy: parsed.s3BucketPolicy } : {}),
+    };
+    return row;
+}
+function parseBucketTypeLiteral(lit, sourceFile) {
+    const out = {};
+    for (const member of lit.members) {
+        if (!ts.isPropertySignature(member) || !member.type)
+            continue;
+        const key = getPropertyName(member.name);
+        if (!key)
+            continue;
+        if (key === "accessMode") {
+            const mode = parseAccessModeLiteral(member.type, sourceFile);
+            if (mode !== undefined)
+                out.accessMode = mode;
+            continue;
+        }
+        if (key === "maxSize") {
+            const s = parseSizeStringLiteral(member.type, sourceFile);
+            if (s !== undefined) {
+                const bytes = parseDataSizeBytes(s);
+                out.fileSizeLimit = bytes;
+            }
+            continue;
+        }
+        if (key === "accept") {
+            const types = parseMimeAcceptList(member.type, sourceFile);
+            if (types !== undefined)
+                out.allowedMimeTypes = types;
+            continue;
+        }
+        if (key === "access") {
+            const acc = parsePartialBucketAccess(member.type, sourceFile);
+            if (acc !== undefined && Object.keys(acc).length > 0)
+                out.access = acc;
+            continue;
+        }
+        if (key === "s3BucketPolicy") {
+            const pol = parseJsonStringLiteral(member.type, sourceFile);
+            if (pol !== undefined)
+                out.s3BucketPolicy = pol;
+            continue;
+        }
+    }
+    return out;
+}
+function parseAccessModeLiteral(typeNode, sourceFile) {
+    const text = stripQuotes(typeNode.getText(sourceFile));
+    if (text === "public" || text === "private" || text === "custom")
+        return text;
+    return undefined;
+}
+function parseSizeStringLiteral(typeNode, sourceFile) {
+    if (ts.isLiteralTypeNode(typeNode) && ts.isStringLiteral(typeNode.literal)) {
+        return typeNode.literal.text;
+    }
+    return stripQuotes(typeNode.getText(sourceFile)) || undefined;
+}
+function parseJsonStringLiteral(typeNode, sourceFile) {
+    return parseSizeStringLiteral(typeNode, sourceFile);
+}
+function parseMimeAcceptList(typeNode, sourceFile) {
+    if (ts.isTypeOperatorNode(typeNode) && typeNode.operator === ts.SyntaxKind.ReadonlyKeyword) {
+        return parseMimeAcceptList(typeNode.type, sourceFile);
+    }
+    if (ts.isTupleTypeNode(typeNode)) {
+        const values = [];
+        for (const el of typeNode.elements) {
+            const node = ts.isNamedTupleMember(el) ? el.type : el;
+            const s = literalStringType(node);
+            if (!s)
+                return undefined;
+            values.push(s);
+        }
+        return values.length > 0 ? values : undefined;
+    }
+    if (ts.isUnionTypeNode(typeNode)) {
+        const values = [];
+        for (const u of typeNode.types) {
+            const s = literalStringType(u);
+            if (!s)
+                return undefined;
+            values.push(s);
+        }
+        return values.length > 0 ? values : undefined;
+    }
+    return undefined;
+}
+function parsePartialBucketAccess(typeNode, sourceFile) {
+    if (!ts.isTypeLiteralNode(typeNode))
+        return undefined;
+    const access = {};
+    for (const member of typeNode.members) {
+        if (!ts.isPropertySignature(member) || !member.type)
+            continue;
+        const key = getPropertyName(member.name);
+        if (key !== "read" && key !== "create" && key !== "delete")
+            continue;
+        access[key] = parseAccessRule(member.type, sourceFile);
+    }
+    return access;
+}
+/** Parse human-readable size from schema types, e.g. `50MB`. */
+function parseDataSizeBytes(lit) {
+    const m = lit.trim().match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)$/i);
+    if (!m?.[1] || !m[2])
+        throw new Error(`Invalid maxSize literal: "${lit}". Use forms like "50MB", "100KB".`);
+    const n = Number(m[1]);
+    if (!Number.isFinite(n) || n < 0)
+        throw new Error(`Invalid maxSize number in: "${lit}"`);
+    const pow = {
+        B: 0,
+        KB: 10,
+        MB: 20,
+        GB: 30,
+    };
+    const unit = m[2].toUpperCase();
+    const exp = pow[unit];
+    if (exp === undefined)
+        throw new Error(`Unsupported maxSize unit in: "${lit}"`);
+    return Math.round(n * Math.pow(2, exp));
+}
+function stripQuotes(s) {
+    return s.replace(/^['"]|['"]$/g, "");
+}
+function bucketsEqual(a, b) {
+    return (a.public === b.public &&
+        (a.accessMode ?? "private") === (b.accessMode ?? "private") &&
+        JSON.stringify(a.access ?? null) === JSON.stringify(b.access ?? null) &&
+        JSON.stringify(a.allowedMimeTypes ?? null) === JSON.stringify(b.allowedMimeTypes ?? null) &&
+        (a.fileSizeLimit ?? null) === (b.fileSizeLimit ?? null) &&
+        (a.s3BucketPolicy ?? null) === (b.s3BucketPolicy ?? null));
+}
+function attachStorageFieldMeta(field, bucketId, bucketsById) {
+    const cfg = bucketsById.get(bucketId);
+    if (cfg?.accessMode !== undefined) {
+        return {
+            ...field,
+            kernel: { ...field.kernel, accessMode: cfg.accessMode },
+        };
+    }
+    return field;
+}
+function parseBlocksTypeDefinitions(blocksArg, sourceFile, blockAliases, bucketAliases, bucketsById, context = {}, resolveCtx) {
+    if (!blocksArg)
+        return [];
+    const parts = ts.isUnionTypeNode(blocksArg) ? blocksArg.types : [blocksArg];
+    const out = [];
+    for (const part of parts) {
+        if (ts.isTypeReferenceNode(part) && ts.isIdentifier(part.typeName)) {
+            if (part.typeName.text === "Block") {
+                const inline = parseInlineBlockDefinition(part, sourceFile, blockAliases, bucketAliases, bucketsById, context, resolveCtx);
+                if (inline)
+                    out.push(inline);
+                continue;
+            }
+            const aliased = blockAliases.get(part.typeName.text);
+            if (aliased)
+                out.push(aliased);
+        }
+    }
+    return out;
+}
+function parseInlineBlockDefinition(ref, sourceFile, blockAliases, bucketAliases, bucketsById, context = {}, resolveCtx) {
+    const [nameArg, fieldsArg, metaArg] = ref.typeArguments ?? [];
+    const name = literalStringType(nameArg);
+    if (!name || !fieldsArg || !ts.isTypeLiteralNode(fieldsArg))
+        return null;
+    const fields = {};
+    for (const member of fieldsArg.members) {
+        if (!ts.isPropertySignature(member) || !member.type)
+            continue;
+        const fieldName = getPropertyName(member.name);
+        if (!fieldName)
+            continue;
+        fields[fieldName] = parseFieldType(fieldName, member.type, sourceFile, blockAliases, bucketAliases, bucketsById, context, resolveCtx);
+    }
+    let label;
+    let icon;
+    if (metaArg && ts.isTypeLiteralNode(metaArg)) {
+        for (const m of metaArg.members) {
+            if (!ts.isPropertySignature(m) || !m.type)
+                continue;
+            const key = getPropertyName(m.name);
+            if (!key)
+                continue;
+            const value = literalStringType(m.type);
+            if (!value)
+                continue;
+            if (key === "label")
+                label = value;
+            if (key === "icon")
+                icon = value;
+        }
+    }
+    return {
+        name,
+        ...(label !== undefined && { label }),
+        ...(icon !== undefined && { icon }),
+        fields,
+    };
+}
+function literalStringType(typeNode) {
+    if (!typeNode)
+        return null;
+    if (ts.isLiteralTypeNode(typeNode) && ts.isStringLiteral(typeNode.literal))
+        return typeNode.literal.text;
+    return null;
+}
+/** Field names referenced in `{name}` and `{truncate(name, n)}` (case-sensitive, same as model fields). */
+function fieldNamesInComputedTemplate(template) {
+    const fields = new Set();
+    const reTrunc = /\{truncate\s*\(\s*([a-zA-Z_]\w*)\s*,\s*(\d+)\s*\)\}/gi;
+    let m;
+    while ((m = reTrunc.exec(template)) !== null) {
+        const ref = m[1];
+        if (ref)
+            fields.add(ref);
+    }
+    const reSimple = /\{([a-zA-Z_]\w*)\}/g;
+    while ((m = reSimple.exec(template)) !== null) {
+        const ref = m[1];
+        if (ref)
+            fields.add(ref);
+    }
+    return [...fields];
+}
+function looksLikeComputedTemplateLiteral(lit) {
+    return /\{truncate\s*\(/i.test(lit) || /\{[a-zA-Z_]\w*\}/g.test(lit);
+}
+/** Resolves second type arg of `ComputedFrom<Value, Sources>` — tuple concat, single field, or template literal. */
+function parseComputedFromSecondArg(sourcesArg, sourceFile) {
+    if (!sourcesArg)
+        return null;
+    const single = literalStringType(sourcesArg);
+    if (single) {
+        if (looksLikeComputedTemplateLiteral(single)) {
+            return { sources: fieldNamesInComputedTemplate(single), template: single };
+        }
+        return { sources: [single] };
+    }
+    const elemsFromTupleType = (tuple) => {
+        const nodes = [];
+        for (const el of tuple.elements) {
+            if (ts.isNamedTupleMember(el)) {
+                if (!el.type)
+                    return null;
+                nodes.push(el.type);
+                continue;
+            }
+            nodes.push(el);
+        }
+        return nodes;
+    };
+    const tupleElems = () => {
+        if (ts.isTupleTypeNode(sourcesArg))
+            return elemsFromTupleType(sourcesArg);
+        if (ts.isTypeOperatorNode(sourcesArg) && sourcesArg.operator === ts.SyntaxKind.ReadonlyKeyword) {
+            const inner = sourcesArg.type;
+            if (inner && ts.isTupleTypeNode(inner))
+                return elemsFromTupleType(inner);
+        }
+        return null;
+    };
+    const elems = tupleElems();
+    if (!elems || elems.length === 0)
+        return null;
+    const keys = [];
+    for (const node of elems) {
+        const k = literalStringType(node);
+        if (!k)
+            return null;
+        keys.push(k);
+    }
+    return { sources: keys };
+}
+function resolveBucketName(typeArg, sourceFile, bucketAliases, fallback) {
+    if (!typeArg)
+        return fallback;
+    if (ts.isTypeReferenceNode(typeArg) && ts.isIdentifier(typeArg.typeName)) {
+        return bucketAliases.get(typeArg.typeName.text) ?? typeArg.typeName.text;
+    }
+    if (ts.isLiteralTypeNode(typeArg) && ts.isStringLiteral(typeArg.literal)) {
+        return typeArg.literal.text;
+    }
+    return typeArg.getText(sourceFile).replace(/^['"]|['"]$/g, "") || fallback;
+}
+function isBooleanLiteralType(typeNode, value) {
+    if (value) {
+        if (typeNode.kind === ts.SyntaxKind.TrueKeyword)
+            return true;
+        if (ts.isLiteralTypeNode(typeNode) && typeNode.literal.kind === ts.SyntaxKind.TrueKeyword) {
+            return true;
+        }
+        return false;
+    }
+    if (typeNode.kind === ts.SyntaxKind.FalseKeyword)
+        return true;
+    if (ts.isLiteralTypeNode(typeNode) && typeNode.literal.kind === ts.SyntaxKind.FalseKeyword) {
+        return true;
+    }
+    return false;
+}
+function parseAssetFieldOptions(optionsArg, sourceFile) {
+    if (!optionsArg || !ts.isTypeLiteralNode(optionsArg))
+        return { localized: false };
+    for (const member of optionsArg.members) {
+        if (!ts.isPropertySignature(member) || !member.type)
+            continue;
+        const key = getPropertyName(member.name);
+        if (key === "localized" && isBooleanLiteralType(member.type, true)) {
+            return { localized: true };
+        }
+    }
+    return { localized: false };
+}
+function parseMetaLiteral(metaArg, sourceFile) {
+    const result = {};
+    if (!metaArg || !ts.isTypeLiteralNode(metaArg))
+        return result;
+    for (const member of metaArg.members) {
+        if (!ts.isPropertySignature(member) || !member.type)
+            continue;
+        const key = getPropertyName(member.name);
+        if (!key)
+            continue;
+        if (key === "singleton" && isBooleanLiteralType(member.type, true)) {
+            result.singleton = true;
+        }
+        else if (key === "timestamps") {
+            if (isBooleanLiteralType(member.type, true))
+                result.timestamps = true;
+            if (isBooleanLiteralType(member.type, false))
+                result.timestamps = false;
+        }
+        else if (key === "softDelete") {
+            if (isBooleanLiteralType(member.type, true))
+                result.softDelete = true;
+            if (isBooleanLiteralType(member.type, false))
+                result.softDelete = false;
+        }
+        else if (key === "autoLocalize" && isBooleanLiteralType(member.type, true)) {
+            result.autoLocalize = true;
+        }
+        else if (key === "tableName" &&
+            ts.isLiteralTypeNode(member.type) &&
+            ts.isStringLiteral(member.type.literal)) {
+            result.tableName = member.type.literal.text;
+        }
+    }
+    return result;
+}
+function hasCompositeWrapper(typeNode, wrapperName) {
+    if (!ts.isTypeReferenceNode(typeNode) || !ts.isIdentifier(typeNode.typeName))
+        return false;
+    if (typeNode.typeName.text === wrapperName)
+        return true;
+    if (typeNode.typeName.text === "WithTimestamps" ||
+        typeNode.typeName.text === "WithSoftDelete" ||
+        typeNode.typeName.text === "WithPublishable") {
+        const inner = typeNode.typeArguments?.[0];
+        if (inner)
+            return hasCompositeWrapper(inner, wrapperName);
+    }
+    return false;
+}
+function parseModelMeta(metaArg, sourceFile, modelName, fieldsArg, fields) {
+    const literal = parseMetaLiteral(metaArg, sourceFile);
+    const singleton = literal.singleton === true;
+    const tableName = literal.tableName ?? (singleton ? `_global_${toSnakeCase(modelName)}` : toSnakeCase(modelName));
+    const timestamps = literal.timestamps ??
+        (hasCompositeWrapper(fieldsArg, "WithTimestamps") ||
+            (fields["created_at"] !== undefined && fields["updated_at"] !== undefined));
+    const softDelete = literal.softDelete ??
+        (hasCompositeWrapper(fieldsArg, "WithSoftDelete") || fields["deleted_at"] !== undefined);
+    const options = {};
+    if (singleton)
+        options.singleton = true;
+    if (timestamps)
+        options.timestamps = true;
+    if (softDelete)
+        options.softDelete = true;
+    if (literal.autoLocalize === true)
+        options.autoLocalize = true;
+    return {
+        tableName,
+        access: parseModelAccess(metaArg, sourceFile),
+        options,
+    };
+}
+function parseModelAccess(metaArg, sourceFile) {
+    if (!metaArg || !ts.isTypeLiteralNode(metaArg))
+        return {};
+    const accessProp = metaArg.members.find((member) => ts.isPropertySignature(member) && getPropertyName(member.name) === "access");
+    if (!accessProp || !ts.isPropertySignature(accessProp) || !accessProp.type || !ts.isTypeLiteralNode(accessProp.type)) {
+        return {};
+    }
+    const access = {};
+    for (const member of accessProp.type.members) {
+        if (!ts.isPropertySignature(member) || !member.type)
+            continue;
+        const key = getPropertyName(member.name);
+        if (!key)
+            continue;
+        access[key] = parseAccessRule(member.type, sourceFile);
+    }
+    return access;
+}
+function parseAccessRule(typeNode, sourceFile) {
+    if (!ts.isTypeReferenceNode(typeNode))
+        return { type: "private" };
+    const ref = typeNode.typeName.getText(sourceFile);
+    switch (ref) {
+        case "Public":
+        case "BucketPublic":
+            return { type: "public" };
+        case "LoggedIn":
+        case "BucketLoggedIn":
+            return { type: "authenticated" };
+        case "Private":
+        case "BucketPrivate":
+            return { type: "private" };
+        case "BucketOwner":
+            return { type: "owner", field: "owner_id" };
+        case "Owner": {
+            const args = typeNode.typeArguments ?? [];
+            const keyArg = args.length >= 2 ? args[1] : args[0];
+            // Must match engine `AccessRule::Owner { field }` (see supatype-schema-engine parser/ast.rs).
+            return { type: "owner", field: keyArg?.getText(sourceFile).replace(/['"]/g, "") ?? "user_id" };
+        }
+        case "OwnerFrom": {
+            const relationArg = typeNode.typeArguments?.[0];
+            const relationField = relationArg?.getText(sourceFile).replace(/['"]/g, "") ?? "owner";
+            return { type: "owner", field: relationField };
+        }
+        case "Role": {
+            const roleArg = typeNode.typeArguments?.[0];
+            return { type: "role", roles: [roleArg?.getText(sourceFile).replace(/['"]/g, "") ?? "admin"] };
+        }
+        case "BucketRole": {
+            const roleArg = typeNode.typeArguments?.[0];
+            return { type: "role", roles: [roleArg?.getText(sourceFile).replace(/['"]/g, "") ?? "admin"] };
+        }
+        default:
+            return { type: "private" };
+    }
+}
+function relationTargetFromTypeArg(typeArg, sourceFile) {
+    if (!typeArg)
+        return "unknown";
+    const raw = typeArg.getText(sourceFile).replace(/\s/g, "");
+    if (raw === "SupatypeAuthUser")
+        return "supatype:user";
+    return raw.replace(/\W/g, "");
+}
+function toSnakeCase(s) {
+    return s.replace(/([A-Z])/g, "_$1").replace(/^_/, "").toLowerCase();
+}
+function relationForeignKeyFromField(fieldName) {
+    const snake = fieldName
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .toLowerCase();
+    const base = snake.replace(/_id$/i, "");
+    return `${base}_id`;
+}
+//# sourceMappingURL=type-extractor.js.map