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

package/dist/type-extractor.js

@@ -0,0 +1,876 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import ts from "typescript";
+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 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);
+        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;
+            if (stmt.type.typeName.getText(sourceFile) !== "Model")
+                continue;
+            const [fieldsArg, metaArg] = stmt.type.typeArguments ?? [];
+            if (!fieldsArg)
+                continue;
+            const fieldsLiteral = unwrapModelFields(fieldsArg);
+            if (!fieldsLiteral)
+                continue;
+            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);
+            }
+            models.push({
+                name: stmt.name.text,
+                tableName: toSnakeCase(stmt.name.text),
+                fields,
+                access: parseModelAccess(metaArg, sourceFile),
+                indexes: [],
+                options: {},
+            });
+        }
+    }
+    if (models.length === 0)
+        return null;
+    const storageBuckets = bucketsById.size > 0 ? [...bucketsById.values()].sort((a, b) => a.id.localeCompare(b.id)) : undefined;
+    return {
+        models,
+        ...(storageBuckets !== undefined && storageBuckets.length > 0 && { storageBuckets }),
+    };
+}
+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) {
+            if (!ts.isExportDeclaration(stmt))
+                continue;
+            if (!stmt.moduleSpecifier || !ts.isStringLiteral(stmt.moduleSpecifier))
+                continue;
+            const nextPath = resolveTypeModulePath(baseDir, stmt.moduleSpecifier.text);
+            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) {
+    if (ts.isTypeLiteralNode(typeNode))
+        return typeNode;
+    if (!ts.isTypeReferenceNode(typeNode) || !ts.isIdentifier(typeNode.typeName))
+        return null;
+    // Composite helpers in @supatype/types wrap the concrete field object.
+    if (typeNode.typeName.text === "WithTimestamps" ||
+        typeNode.typeName.text === "WithSoftDelete" ||
+        typeNode.typeName.text === "WithPublishable") {
+        const inner = typeNode.typeArguments?.[0];
+        if (!inner)
+            return null;
+        return unwrapModelFields(inner);
+    }
+    return null;
+}
+function parseFieldType(fieldName, typeNode, sourceFile, blockAliases, bucketAliases, bucketsById) {
+    const flags = {
+        required: true,
+        unique: false,
+        index: false,
+        primaryKey: false,
+        serverGenerated: false,
+        autoIncrement: false,
+        relationCardinality: undefined,
+        relationTarget: undefined,
+        editorReadOnly: false,
+        /** When set from `ComputedFrom`, Studio previews from these sources until edited on create */
+        computedFromSources: undefined,
+        /** When set, second arg was a template literal with `{field}` / `{truncate(f, n)}` */
+        computedFromTemplate: undefined,
+    };
+    let current = typeNode;
+    while (ts.isTypeReferenceNode(current) && ts.isIdentifier(current.typeName)) {
+        const typeName = current.typeName.text;
+        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":
+                // Default<T, V> — 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 "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 {
+                    kind: "relation",
+                    cardinality: "belongsTo",
+                    target: flags.relationTarget,
+                    foreignKey: relationForeignKeyFromField(fieldName),
+                    ...(flags.editorReadOnly && { readOnly: true }),
+                };
+            case "HasOne":
+                flags.relationCardinality = "one";
+                flags.relationTarget = current.typeArguments?.[0]?.getText(sourceFile).replace(/\W/g, "") ?? "unknown";
+                return {
+                    kind: "relation",
+                    cardinality: "hasOne",
+                    target: flags.relationTarget,
+                    ...(flags.editorReadOnly && { readOnly: true }),
+                };
+            case "HasMany":
+            case "ManyToMany":
+                flags.relationCardinality = "many";
+                flags.relationTarget = current.typeArguments?.[0]?.getText(sourceFile).replace(/\W/g, "") ?? "unknown";
+                return {
+                    kind: "relation",
+                    cardinality: "hasMany",
+                    target: flags.relationTarget,
+                    ...(flags.editorReadOnly && { readOnly: true }),
+                };
+            default:
+                break;
+        }
+        break;
+    }
+    const scalar = parseScalarType(current, sourceFile, blockAliases, bucketAliases, bucketsById);
+    const parsed = {
+        ...scalar,
+        required: flags.required,
+        unique: flags.unique,
+        index: flags.index,
+        ...(flags.primaryKey && { primaryKey: true }),
+        ...(flags.editorReadOnly && { readOnly: true }),
+    };
+    if (flags.autoIncrement && parsed.kind === "integer") {
+        parsed.kind = "serial";
+        parsed.pgType = "SERIAL";
+    }
+    // RFC parity with existing examples: `id: UUID` should be the model PK unless
+    // explicitly overridden via wrappers such as PrimaryKey<> in source types.
+    if (fieldName === "id" &&
+        parsed.kind === "uuid" &&
+        flags.primaryKey === false) {
+        parsed.primaryKey = true;
+        parsed.unique = true;
+        parsed.required = true;
+    }
+    // Align with engine fixtures: PK UUID is created by the database unless the author supplies one.
+    if (parsed.primaryKey === true && parsed.kind === "uuid") {
+        parsed.default = { kind: "genRandomUuid" };
+    }
+    else if (parsed.primaryKey === true && (parsed.kind === "serial" || parsed.kind === "bigSerial")) {
+        flags.serverGenerated = true;
+    }
+    if (flags.serverGenerated === true) {
+        parsed.serverGenerated = true;
+    }
+    // Convention: standard audit columns are filled by the DB on insert/update.
+    const auditTs = fieldName === "created_at" ||
+        fieldName === "updated_at" ||
+        fieldName === "createdAt" ||
+        fieldName === "updatedAt";
+    if (auditTs) {
+        parsed.serverGenerated = true;
+        if ((parsed.kind === "datetime" || parsed.kind === "date") &&
+            parsed.default === undefined) {
+            parsed.default = { kind: "now" };
+        }
+    }
+    // `ServerDefault<Date>` etc. → DEFAULT NOW() for column types Postgres handles with NOW().
+    if (flags.serverGenerated &&
+        (parsed.kind === "datetime" || parsed.kind === "date") &&
+        parsed.default === undefined) {
+        parsed.default = { kind: "now" };
+    }
+    const hasCfTemplate = flags.computedFromTemplate !== undefined;
+    const hasCfSources = Boolean(flags.computedFromSources && flags.computedFromSources.length > 0);
+    if (parsed.kind === "text" && (hasCfTemplate || hasCfSources)) {
+        return {
+            ...parsed,
+            ...(hasCfSources && { sources: flags.computedFromSources }),
+            ...(hasCfTemplate && { template: flags.computedFromTemplate }),
+        };
+    }
+    return parsed;
+}
+function parseScalarType(typeNode, sourceFile, blockAliases, bucketAliases, bucketsById) {
+    if (ts.isArrayTypeNode(typeNode)) {
+        const element = parseScalarType(typeNode.elementType, sourceFile, blockAliases, bucketAliases, bucketsById);
+        const elementKind = typeof element.kind === "string" ? element.kind : "text";
+        // Keep arrays as native SQL arrays (old `arrayOf(...)` parity), not JSONB.
+        return {
+            kind: "array",
+            pgType: "ARRAY",
+            elementType: elementKind,
+        };
+    }
+    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 {
+                kind: "enum",
+                pgType: "TEXT",
+                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);
+    }
+    if (ts.isTypeReferenceNode(typeNode)) {
+        const ref = typeNode.typeName.getText(sourceFile);
+        switch (ref) {
+            case "UUID":
+            case "SupatypeAuthUserId":
+                return { kind: "uuid", pgType: "UUID" };
+            case "RichText":
+                return { kind: "richText", pgType: "JSONB" };
+            case "Slug": {
+                const fromArg = typeNode.typeArguments?.[0];
+                const fromLiteral = fromArg ? literalStringType(fromArg) : null;
+                const from = fromLiteral ?? "title";
+                return { kind: "slug", pgType: "TEXT", from };
+            }
+            case "Email":
+                return { kind: "email", pgType: "TEXT" };
+            case "URL":
+                return { kind: "url", pgType: "TEXT" };
+            case "Markdown":
+                return { kind: "text", pgType: "TEXT" };
+            case "Color":
+                return { kind: "color", pgType: "TEXT" };
+            case "PhoneNumber":
+                return { kind: "text", pgType: "TEXT" };
+            case "IPAddress":
+                return { kind: "ip", pgType: "TEXT" };
+            case "CIDR":
+                return { kind: "cidr", pgType: "TEXT" };
+            case "MacAddress":
+                return { kind: "macaddr", pgType: "TEXT" };
+            case "XML":
+                return { kind: "xml", pgType: "TEXT" };
+            case "TSQuery":
+                return { kind: "tsQuery", pgType: "TEXT" };
+            case "TSVector":
+                return { kind: "tsVector", pgType: "TEXT" };
+            case "Money":
+                return { kind: "money", pgType: "TEXT" };
+            case "Decimal":
+                return { kind: "decimal", pgType: "TEXT" };
+            case "DateOnly":
+                return { kind: "date", pgType: "DATE" };
+            case "Date":
+            case "DateTime":
+            case "Timestamp":
+                return { kind: "datetime", pgType: "TIMESTAMP WITH TIME ZONE" };
+            case "Int":
+                return { kind: "integer", pgType: "INTEGER" };
+            case "SmallInt":
+                return { kind: "smallInt", pgType: "SMALLINT" };
+            case "BigInt":
+                return { kind: "bigInt", pgType: "BIGINT" };
+            case "Float":
+                return { kind: "float", pgType: "DOUBLE PRECISION" };
+            case "Bytea":
+                return { kind: "bytes", pgType: "BYTEA" };
+            case "JSON":
+                return { kind: "json", pgType: "JSONB" };
+            case "GeoPoint":
+                return { kind: "geo", pgType: "GEOGRAPHY", geoType: "point", srid: 4326 };
+            case "Geo":
+                return { kind: "geo", pgType: "GEOGRAPHY", geoType: "point", srid: 4326 };
+            case "Asset":
+            case "FileAsset": {
+                const bucket = resolveBucketName(typeNode.typeArguments?.[0], sourceFile, bucketAliases, "assets");
+                return attachStorageFieldMeta({ kind: "file", pgType: "TEXT", bucket }, bucket, bucketsById);
+            }
+            case "ImageAsset": {
+                const bucket = resolveBucketName(typeNode.typeArguments?.[0], sourceFile, bucketAliases, "images");
+                return attachStorageFieldMeta({ kind: "image", pgType: "TEXT", bucket }, bucket, bucketsById);
+            }
+            case "Blocks":
+                return {
+                    kind: "blocks",
+                    pgType: "JSONB",
+                    blocks: parseBlocksTypeDefinitions(typeNode.typeArguments?.[0], sourceFile, blockAliases, bucketAliases, bucketsById),
+                };
+            case "Vector": {
+                const dimensions = typeNode.typeArguments?.[0]?.getText(sourceFile);
+                return { kind: "vector", pgType: "VECTOR", dimensions: Number(dimensions ?? "1536") };
+            }
+            default:
+                return { kind: "text", pgType: "TEXT" };
+        }
+    }
+    switch (typeNode.kind) {
+        case ts.SyntaxKind.StringKeyword:
+            return { kind: "text", pgType: "TEXT" };
+        case ts.SyntaxKind.NumberKeyword:
+            return { kind: "float", pgType: "DOUBLE PRECISION" };
+        case ts.SyntaxKind.BooleanKeyword:
+            return { kind: "boolean", pgType: "BOOLEAN" };
+        default:
+            return { kind: "json", pgType: "JSONB" };
+    }
+}
+function collectBlockAliases(sourceFile, bucketAliases, bucketsById) {
+    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);
+        if (!block)
+            continue;
+        blocks.set(stmt.name.text, block);
+    }
+    return blocks;
+}
+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,
+            ...(cfg.accessMode !== undefined && { accessMode: cfg.accessMode }),
+        };
+    }
+    return field;
+}
+function parseBlocksTypeDefinitions(blocksArg, sourceFile, blockAliases, bucketAliases, bucketsById) {
+    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);
+                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) {
+    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);
+    }
+    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 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: relationForeignKeyFromField(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