@tekki-forge/compiler 0.0.0-stage → 0.1.0

package/dist/compile.js

@@ -0,0 +1,691 @@
+import { BUILTIN_ENTITIES, RESERVED_ENTITY_NAMES, RESERVED_FIELD_NAMES, } from "./ir.js";
+import { compileTheme } from "./theme.js";
+import { compileRule } from "./rules.js";
+import { compileNotifications } from "./notifications.js";
+import { compileDashboard } from "./dashboard.js";
+import { compileI18n } from "./i18n.js";
+import { compileLanding } from "./landing.js";
+import { compileEntityFeatures, compileComputed } from "./features.js";
+import { isCamelCase, isPascalCase, kebabCase, lowerFirst, pluralize, singularize, snakeCase, titleCase } from "./naming.js";
+export class ForgeSchemaError extends Error {
+    issues;
+    constructor(issues) {
+        super(`Invalid Forge schema:\n${issues.map((i) => `  • ${i.path}: ${i.message}`).join("\n")}`);
+        this.issues = issues;
+        this.name = "ForgeSchemaError";
+    }
+}
+const SOCIAL_PROVIDERS = ["google", "microsoft", "github", "apple", "gitlab", "discord"];
+const TEXT_KINDS = new Set(["string", "text", "richtext", "email", "url", "phone", "color"]);
+const NUMBER_KINDS = new Set(["integer", "decimal", "money", "percentage"]);
+const DEFAULT_WIDGETS = {
+    string: "text",
+    text: "textarea",
+    richtext: "markdown",
+    email: "email",
+    url: "url",
+    phone: "tel",
+    color: "color",
+    integer: "number",
+    decimal: "number",
+    money: "money",
+    percentage: "percentage",
+    boolean: "switch",
+    date: "date",
+    datetime: "datetime",
+    enum: "select",
+    json: "json",
+    relation: "relation-select",
+    location: "location",
+    file: "file",
+    image: "image",
+    computed: "computed",
+};
+const COMPUTED_TYPES = ["integer", "decimal", "money", "percentage", "string", "boolean", "date", "datetime"];
+const IMAGE_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif"];
+/** "10MB" | "500KB" | "1.5 GB" | bytes → bytes. */
+export function parseSize(v) {
+    if (typeof v === "number")
+        return Number.isFinite(v) && v > 0 ? Math.floor(v) : undefined;
+    const m = /^\s*(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?\s*$/i.exec(v);
+    if (!m)
+        return undefined;
+    const unit = { b: 1, kb: 1024, mb: 1024 ** 2, gb: 1024 ** 3 }[(m[2] ?? "b").toLowerCase()];
+    return Math.floor(Number(m[1]) * unit);
+}
+const RESERVED_PATHS = ["users", "me", "stats", "audit-logs", "auth", "docs", "health", "openapi.json", "admin", "account", "config", "notifications", "search", "saved-views", "dashboard", "import", "teams", "api-keys"];
+const BUILTIN_RESERVED_INVERSES = ["sessions", "accounts", "members", "invitations", "twoFactors", "passkeys", "auditLogs", "users", "teams", "teamMemberships", "apiKeys", "createdApiKeys"];
+const ICONS = ["folder", "users", "briefcase", "file-text", "box", "tag", "layers", "star"];
+/** Compile a Forge app definition into the normalized IR, collecting every issue before failing. */
+export function compile(config) {
+    const issues = [];
+    const issue = (path, message) => issues.push({ path, message });
+    if (!config || typeof config !== "object")
+        throw new ForgeSchemaError([{ path: "", message: "config must be an object" }]);
+    if (!config.name || typeof config.name !== "string")
+        issue("name", "application name is required");
+    const tenancyEnabled = typeof config.multiTenant === "boolean" ? config.multiTenant : !!config.multiTenant?.enabled;
+    const roles = uniq(["admin", ...(config.roles ?? []), ...(tenancyEnabled ? ["member"] : ["user"])]);
+    for (const role of roles) {
+        if (!/^[a-z][a-z0-9_-]*$/.test(role))
+            issue("roles", `role "${role}" must be lowercase (letters, digits, - or _)`);
+        if (role === "owner" || role === "authenticated" || role === "public" || role === "team") {
+            issue("roles", `"${role}" is a reserved permission token and cannot be used as a role name`);
+        }
+    }
+    const auth = {
+        emailPassword: config.auth?.emailPassword ?? true,
+        registration: config.auth?.registration ?? true,
+        social: [...(config.auth?.social ?? [])],
+        emailVerification: config.auth?.emailVerification ?? false,
+        passwordReset: config.auth?.passwordReset ?? true,
+        twoFactor: config.auth?.twoFactor ?? false,
+        passkeys: config.auth?.passkeys ?? false,
+    };
+    for (const provider of auth.social) {
+        if (!SOCIAL_PROVIDERS.includes(provider))
+            issue("auth.social", `unknown provider "${provider}" (supported: ${SOCIAL_PROVIDERS.join(", ")})`);
+    }
+    if (!auth.emailPassword && auth.social.length === 0 && !auth.passkeys) {
+        issue("auth", "enable at least one sign-in method (emailPassword, social or passkeys)");
+    }
+    if (config.database?.provider && config.database.provider !== "postgresql") {
+        issue("database.provider", `only "postgresql" is supported in this version`);
+    }
+    // Plugins: validate, then merge the entities they contribute into the schema.
+    const plugins = [];
+    const pluginEntities = [];
+    for (const [i, pl] of (config.plugins ?? []).entries()) {
+        const pat = `plugins[${i}]`;
+        if (!pl || typeof pl !== "object" || pl.__forge !== "plugin") {
+            issue(pat, "plugins must be created by a plugin factory, e.g. storage()");
+            continue;
+        }
+        if (plugins.some((x) => x.name === pl.name))
+            issue(pat, `plugin "${pl.name}" is listed twice`);
+        const entityNames = Object.keys(pl.entities ?? {});
+        for (const name of entityNames) {
+            if (config.entities?.[name])
+                issue(`${pat}.entities.${name}`, `plugin "${pl.name}" defines ${name}, which already exists in your entities`);
+            else
+                pluginEntities.push([name, pl.entities[name]]);
+        }
+        plugins.push({
+            name: pl.name,
+            package: pl.package,
+            version: pl.version ?? "0.1.0",
+            options: JSON.parse(JSON.stringify(pl.options ?? {})),
+            runtime: { api: !!pl.runtime?.api, worker: !!pl.runtime?.worker, web: !!pl.runtime?.web },
+            env: (pl.env ?? []).map((v) => ({ ...v, required: !!v.required, secret: !!v.secret })),
+            docker: { services: JSON.parse(JSON.stringify(pl.docker?.services ?? {})), volumes: [...(pl.docker?.volumes ?? [])] },
+            nav: (pl.nav ?? []).map((n) => ({ label: n.label, path: n.path, icon: n.icon ?? "box", admin: !!n.admin })),
+            reservedPaths: [...(pl.reservedPaths ?? [])],
+            entities: entityNames,
+        });
+    }
+    for (const [i, pl] of plugins.entries()) {
+        for (const req of (config.plugins?.[i]?.requires ?? [])) {
+            if (!plugins.some((x) => x.name === req))
+                issue(`plugins[${i}]`, `plugin "${pl.name}" requires the "${req}" plugin — add ${req}() to plugins`);
+        }
+    }
+    const reservedPaths = [...RESERVED_PATHS, ...plugins.flatMap((pl) => pl.reservedPaths)];
+    const entityDefs = [...Object.entries(config.entities ?? {}), ...pluginEntities];
+    if (entityDefs.length === 0)
+        issue("entities", "define at least one entity");
+    // Pass 1: entity-level identity (needed to resolve relations in pass 2).
+    const shells = new Map();
+    const reservedEntity = (n) => RESERVED_ENTITY_NAMES.includes(n);
+    for (const [name, def] of entityDefs) {
+        const at = `entities.${name}`;
+        if (!isPascalCase(name))
+            issue(at, "entity names must be PascalCase");
+        if (reservedEntity(name))
+            issue(at, `"${name}" is reserved by Forge`);
+        if (!def || typeof def !== "object" || !def.fields) {
+            issue(at, "entity must be created with entity({ fields: { ... } })");
+            continue;
+        }
+        // The Prisma model follows the storage name, so renaming an entity keeps every database object.
+        const storage = def.storageName ?? name;
+        if (def.storageName !== undefined) {
+            if (typeof def.storageName !== "string" || !isPascalCase(def.storageName))
+                issue(`${at}.storageName`, "must be PascalCase, like an entity name");
+            else if (reservedEntity(def.storageName))
+                issue(`${at}.storageName`, `"${def.storageName}" is reserved by Forge`);
+        }
+        shells.set(name, {
+            def,
+            model: storage,
+            delegate: lowerFirst(storage),
+            path: def.path ?? kebabCase(pluralize(name)),
+            display: def.display ?? pickDisplay(def.fields),
+        });
+    }
+    for (const [n, s] of shells) {
+        if (reservedPaths.includes(s.path))
+            issue(`entities.${n}.path`, `"${s.path}" is reserved by Forge or a plugin; set path: "..."`);
+        if (!/^[a-z0-9][a-z0-9-]*$/.test(s.path))
+            issue(`entities.${n}.path`, "must be lowercase letters, digits and dashes");
+    }
+    checkUnique([...shells].map(([n, s]) => [n, s.path]), "path", issue);
+    checkUnique([...shells].map(([n, s]) => [n, s.model]), "storage name", issue);
+    checkUnique([...shells].map(([n, s]) => [n, s.def.table ?? snakeCase(pluralize(n))]), "table", issue);
+    const entities = [];
+    for (const [name, shell] of shells) {
+        const { def } = shell;
+        const at = `entities.${name}`;
+        const fields = [];
+        for (const [fieldName, fieldDef] of Object.entries(def.fields)) {
+            const fat = `${at}.fields.${fieldName}`;
+            if (!isFieldDefinition(fieldDef)) {
+                issue(fat, "fields must be created with a field builder, e.g. string({ required: true })");
+                continue;
+            }
+            if (!isCamelCase(fieldName))
+                issue(fat, "field names must be camelCase");
+            if (RESERVED_FIELD_NAMES.includes(fieldName))
+                issue(fat, `"${fieldName}" is managed by Forge`);
+            fields.push(compileField(fieldName, fieldDef, fat, shells, issue));
+        }
+        // features.teams: records belong to a team of the organization (built-in Team model).
+        const teamsOn = !!def.features?.teams;
+        if (teamsOn) {
+            if (!tenancyEnabled)
+                issue(`${at}.features.teams`, "teams live inside organizations — enable multiTenant first");
+            if (def.fields.team)
+                issue(`${at}.fields.team`, `"team" is added by features: { teams: true }; remove this field or rename it`);
+            else {
+                const team = compileField("team", { __forge: "field", kind: "relation", options: { entity: "Team", label: "Team", filterable: true } }, `${at}.features.teams`, shells, issue);
+                fields.push(team);
+            }
+        }
+        for (const f of fields) {
+            if (f.relation?.entity === "Team" && !tenancyEnabled && !teamsOn)
+                issue(`${at}.fields.${f.name}`, "relations to Team need multiTenant");
+        }
+        for (const f of fields) {
+            if (!f.relation || f.relation.inverse)
+                continue;
+            const siblings = fields.filter((o) => o.relation?.entity === f.relation.entity).length;
+            f.relation.inverse = siblings > 1 ? `${f.name}${pluralize(name)}` : lowerFirst(pluralize(name));
+            if (f.relation.builtin && BUILTIN_RESERVED_INVERSES.includes(f.relation.inverse)) {
+                issue(`${at}.fields.${f.name}.inverse`, `"${f.relation.inverse}" is used by the built-in ${f.relation.entity} model; set inverse: "..."`);
+            }
+        }
+        const apiNames = new Map();
+        for (const f of fields) {
+            const other = apiNames.get(f.apiName);
+            if (other)
+                issue(`${at}.fields.${f.name}`, `API name "${f.apiName}" collides with field "${other}"`);
+            apiNames.set(f.apiName, f.name);
+        }
+        const scalar = fields.filter((f) => !["relation", "json", "location", "file", "image"].includes(f.kind) && !f.hidden);
+        if (!fields.some((f) => f.name === shell.display) || !scalar.some((f) => f.name === shell.display)) {
+            if (def.display)
+                issue(`${at}.display`, `"${def.display}" must be a visible scalar field`);
+            else if (scalar.length === 0)
+                shell.display = "id";
+        }
+        const userRelations = fields.filter((f) => f.relation?.entity === "User");
+        const explicitOwners = fields.filter((f) => f.relation?.owner);
+        if (explicitOwners.length > 1)
+            issue(at, "only one relation can be marked as owner");
+        for (const o of explicitOwners) {
+            if (o.relation.entity !== "User")
+                issue(`${at}.fields.${o.name}`, "the owner relation must target User");
+        }
+        const ownerField = explicitOwners[0] ?? userRelations.find((f) => f.name === "owner");
+        if (ownerField?.relation)
+            ownerField.relation.owner = true;
+        const features = {
+            timestamps: def.features?.timestamps ?? true,
+            softDelete: def.features?.softDelete ?? false,
+            audit: def.features?.audit ?? false,
+            tenant: def.features?.tenant ?? tenancyEnabled,
+            export: def.features?.export ?? true,
+            bulkDelete: def.features?.bulkDelete ?? true,
+            ...(teamsOn ? { teams: true } : {}),
+            comments: def.features?.comments ?? false,
+        };
+        if (def.features?.comments !== undefined && typeof def.features.comments !== "boolean")
+            issue(`${at}.features.comments`, "must be true or false");
+        if (features.tenant && !tenancyEnabled)
+            issue(`${at}.features.tenant`, "requires multiTenant to be enabled");
+        const hasOwner = !!ownerField;
+        const hasTeam = teamsOn && fields.some((f) => f.name === "team");
+        const defaults = {
+            create: ["authenticated"],
+            read: ["authenticated"],
+            update: hasOwner ? ["admin", "owner"] : ["authenticated"],
+            delete: hasOwner ? ["admin", "owner"] : ["admin"],
+        };
+        const permissions = {};
+        for (const op of ["create", "read", "update", "delete"]) {
+            permissions[op] = compileRule(def.permissions?.[op] ?? defaults[op], `${at}.permissions.${op}`, op, roles, hasOwner, issue, hasTeam);
+        }
+        const actions = Object.entries(def.actions ?? {}).map(([actionName, a]) => {
+            const aat = `${at}.actions.${actionName}`;
+            if (!isCamelCase(actionName))
+                issue(aat, "action names must be camelCase");
+            return {
+                name: actionName,
+                label: a.label ?? titleCase(actionName),
+                ...(a.confirm ? { confirm: a.confirm } : {}),
+                variant: a.variant ?? "default",
+                permission: a.permission ? compileRule(a.permission, `${aat}.permission`, "update", roles, hasOwner, issue, hasTeam) : permissions.update,
+            };
+        });
+        const systemSortable = ["id", ...(features.timestamps ? ["createdAt", "updatedAt"] : [])];
+        const sortable = new Set([...fields.filter((f) => f.sortable).map((f) => f.name), ...systemSortable]);
+        const defaultSort = parseSort(def.list?.defaultSort ?? (features.timestamps ? "-createdAt" : shell.display));
+        if (!sortable.has(defaultSort.field))
+            issue(`${at}.list.defaultSort`, `"${defaultSort.field}" is not a sortable field`);
+        const known = new Set([...fields.map((f) => f.name), ...systemSortable]);
+        const columns = def.list?.columns ? [...def.list.columns] : defaultColumns(fields, shell.display, features.timestamps);
+        for (const c of columns)
+            if (!known.has(c))
+                issue(`${at}.list.columns`, `unknown column "${c}"`);
+        for (const f of fields)
+            f.list = columns.includes(f.name);
+        const pageSize = def.list?.pageSize ?? 20;
+        if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 500)
+            issue(`${at}.list.pageSize`, "must be an integer between 1 and 500");
+        const entity = {
+            name,
+            label: def.label ?? titleCase(name),
+            pluralLabel: def.pluralLabel ?? pluralize(def.label ?? titleCase(name)),
+            ...(def.description ? { description: def.description } : {}),
+            model: shell.model,
+            storageName: shell.model,
+            delegate: shell.delegate,
+            tableName: def.table ?? snakeCase(pluralize(name)),
+            path: shell.path,
+            display: shell.display,
+            icon: def.icon ?? ICONS[entities.length % ICONS.length],
+            nav: def.nav ?? true,
+            fields,
+            inverseRelations: [],
+            ...(ownerField ? { ownerField: ownerField.name } : {}),
+            ...(hasTeam ? { teamField: "team" } : {}),
+            permissions,
+            features,
+            actions,
+            list: { columns, defaultSort, pageSize },
+            views: {},
+            computedOrder: [],
+            aggregateParents: [],
+        };
+        compileEntityFeatures(entity, def, { roles, hasOwner, hasTeam, issue });
+        entities.push(entity);
+    }
+    // Pass 3: inverse (one-to-many) relations on target entities.
+    const byName = new Map(entities.map((e) => [e.name, e]));
+    for (const source of entities) {
+        for (const f of source.fields) {
+            if (!f.relation)
+                continue;
+            const target = byName.get(f.relation.entity);
+            if (!target)
+                continue;
+            const clash = target.fields.find((tf) => tf.name === f.relation.inverse) ?? target.inverseRelations.find((ir) => ir.name === f.relation.inverse);
+            if (clash) {
+                issue(`entities.${source.name}.fields.${f.name}.inverse`, `"${f.relation.inverse}" already exists on ${target.name}; set a different inverse name`);
+                continue;
+            }
+            target.inverseRelations.push({
+                type: f.relation.type === "many-to-many" ? "many-to-many" : "one-to-many",
+                name: f.relation.inverse,
+                label: source.pluralLabel,
+                entity: source.name,
+                field: f.name,
+                foreignKey: f.relation.foreignKey,
+            });
+        }
+    }
+    // Two relations from the same source to User would produce ambiguous back-relations on User.
+    for (const source of entities) {
+        const seen = new Map();
+        for (const f of source.fields) {
+            if (!f.relation?.builtin)
+                continue;
+            const key = `${f.relation.entity}.${f.relation.inverse}`;
+            if (seen.has(key))
+                issue(`entities.${source.name}.fields.${f.name}.inverse`, `duplicate inverse name "${f.relation.inverse}" on ${f.relation.entity}`);
+            seen.set(key, f.name);
+        }
+    }
+    // The built-in RecordComment model adds `recordComments` to User.
+    if (entities.some((e) => e.features.comments)) {
+        for (const e of entities) {
+            for (const f of e.fields) {
+                if (f.relation?.entity === "User" && f.relation.inverse === "recordComments") {
+                    issue(`entities.${e.name}.fields.${f.name}.inverse`, `"recordComments" is used by the built-in RecordComment model on User; set inverse: "..."`);
+                }
+            }
+        }
+    }
+    compileComputed(entities, issue);
+    if (!plugins.some((pl) => pl.name === "storage")) {
+        for (const e of entities) {
+            for (const f of e.fields) {
+                if (f.file)
+                    issue(`entities.${e.name}.fields.${f.name}`, `${f.kind} fields need file storage — add storage() from "@tekki-forge/plugin-storage" to plugins (or run forge add storage)`);
+            }
+        }
+    }
+    const notifications = compileNotifications(config.notifications, entities, roles, issue);
+    const dashboard = compileDashboard(config.dashboard, entities, issue);
+    const theme = compileTheme(config.theme, issue);
+    const i18n = compileI18n(config.i18n, issue);
+    const teamsEnabled = tenancyEnabled && entities.some((e) => e.fields.some((f) => f.relation?.entity === "Team"));
+    const backups = compileBackups(config.backups, issue);
+    const sdk = compileSdk(config.sdk, issue);
+    const landing = compileLanding(config.landing, issue);
+    if (issues.length > 0)
+        throw new ForgeSchemaError(issues);
+    return {
+        irVersion: 1,
+        name: config.name,
+        slug: kebabCase(config.name),
+        ...(config.description ? { description: config.description } : {}),
+        database: { provider: "postgresql" },
+        auth,
+        tenancy: { enabled: tenancyEnabled, model: "organization" },
+        roles,
+        api: { prefix: config.api?.prefix ?? "/api", docs: config.api?.docs ?? true },
+        sdk,
+        admin: { enabled: config.admin?.enabled ?? true },
+        theme,
+        plugins,
+        notifications,
+        dashboard,
+        i18n,
+        entities,
+        teams: { enabled: teamsEnabled },
+        ...(backups ? { backups } : {}),
+        ...(landing ? { landing } : {}),
+    };
+}
+/** Five-field cron ("0 3 * * *"): minute hour day-of-month month day-of-week. */
+export function isCronPattern(v) {
+    const parts = v.trim().split(/\s+/);
+    return parts.length === 5 && parts.every((p) => /^(\*|\d+(-\d+)?)(\/\d+)?(,(\*|\d+(-\d+)?)(\/\d+)?)*$/.test(p));
+}
+function compileBackups(raw, issue) {
+    if (raw === undefined)
+        return undefined;
+    if (!raw || typeof raw !== "object") {
+        issue("backups", "must be an object, e.g. { schedule: \"0 3 * * *\", keep: 14 }");
+        return undefined;
+    }
+    const keep = raw.keep ?? 14;
+    if (!Number.isInteger(keep) || keep < 1 || keep > 1000)
+        issue("backups.keep", "must be an integer between 1 and 1000");
+    if (raw.schedule !== undefined && (typeof raw.schedule !== "string" || !isCronPattern(raw.schedule))) {
+        issue("backups.schedule", `"${String(raw.schedule)}" is not a cron pattern (minute hour day month weekday), e.g. "0 3 * * *"`);
+    }
+    return { schedule: raw.schedule ?? null, keep };
+}
+const SDK_LANGUAGES = ["typescript", "python", "dart"];
+function compileSdk(config, issue) {
+    const languages = [];
+    for (const [i, l] of (config?.languages ?? ["typescript"]).entries()) {
+        if (!SDK_LANGUAGES.includes(l))
+            issue(`sdk.languages[${i}]`, `unknown SDK language "${l}" (supported: ${SDK_LANGUAGES.join(", ")})`);
+        else if (!languages.includes(l))
+            languages.push(l);
+    }
+    return { languages };
+}
+function compileField(name, def, at, shells, issue) {
+    const o = def.options ?? {};
+    const isComputed = def.kind === "computed";
+    if (isComputed && !COMPUTED_TYPES.includes(o.type))
+        issue(`${at}.type`, `computed fields need a type: ${COMPUTED_TYPES.join(", ")}`);
+    if (isComputed && (typeof o.expression !== "string" || !o.expression.trim()))
+        issue(`${at}.expression`, "computed fields need an expression");
+    // A computed field is stored as its result type and is never writable.
+    const kind = (isComputed ? (COMPUTED_TYPES.includes(o.type) ? o.type : "string") : def.kind);
+    if (!DEFAULT_WIDGETS[kind])
+        issue(at, `unknown field type "${kind}"`);
+    const isText = TEXT_KINDS.has(kind);
+    const isNumber = NUMBER_KINDS.has(kind);
+    const isRelation = kind === "relation";
+    const isFile = kind === "file" || kind === "image";
+    const isManyToMany = isRelation && o.type === "many-to-many";
+    const isScalarSortable = !["json", "richtext", "text", "location", "file", "image"].includes(kind);
+    const field = {
+        name,
+        kind,
+        label: o.label ?? titleCase(name),
+        ...(o.description ? { description: o.description } : {}),
+        required: !!o.required,
+        unique: !!o.unique,
+        index: !!o.index,
+        searchable: o.searchable ?? false,
+        filterable: o.filterable ?? (kind === "enum" || kind === "boolean" || isRelation),
+        sortable: o.sortable ?? (isScalarSortable && !isRelation),
+        list: !!o.list,
+        hidden: !!o.hidden,
+        readonly: !!o.readonly || isComputed,
+        widget: o.widget ?? DEFAULT_WIDGETS[kind] ?? "text",
+        ...(o.placeholder ? { placeholder: o.placeholder } : {}),
+        column: snakeCase(name),
+        apiName: name,
+        validation: {},
+    };
+    if (field.searchable && !isText)
+        issue(`${at}.searchable`, "only text fields can be searchable");
+    if (field.unique && (kind === "json" || isRelation || isFile || kind === "location"))
+        issue(`${at}.unique`, `not supported for ${kind} fields`);
+    if (isComputed) {
+        if (o.required || o.unique || o.default !== undefined)
+            issue(at, "computed fields cannot be required, unique or have a default");
+        if (o.searchable && kind !== "string")
+            issue(`${at}.searchable`, "only text fields can be searchable");
+        field.required = false;
+        field.computed = { expression: String(o.expression ?? ""), ast: null, fields: [], aggregates: [] };
+    }
+    if ((kind === "location" || isFile) && (o.filterable || o.sortable))
+        issue(at, `${kind} fields cannot be filtered or sorted`);
+    if (kind === "location") {
+        field.filterable = false;
+        field.sortable = false;
+    }
+    if (isFile) {
+        const image = kind === "image";
+        const maxSize = o.maxSize === undefined ? (image ? 5 : 10) * 1024 ** 2 : parseSize(o.maxSize);
+        if (!maxSize)
+            issue(`${at}.maxSize`, 'use a size like "10MB", "500KB" or a number of bytes');
+        const accept = [...(o.accept ?? (image ? IMAGE_TYPES : []))].map((a) => a.trim().toLowerCase());
+        for (const a of accept) {
+            if (!/^(\.[a-z0-9]+|[a-z]+\/([a-z0-9.+-]+|\*))$/.test(a))
+                issue(`${at}.accept`, `"${a}" is not a MIME type (image/png, image/*) or extension (.pdf)`);
+            if (image && !a.startsWith("image/") && !/^\.(png|jpe?g|gif|webp|avif)$/.test(a))
+                issue(`${at}.accept`, `image fields only accept images, not "${a}"`);
+            if (a === "image/svg+xml" || a === ".svg")
+                issue(`${at}.accept`, "SVG can carry scripts; upload it with file() — it is then always downloaded, never displayed inline");
+        }
+        field.apiName = `${name}Id`;
+        field.column = `${snakeCase(name)}_id`;
+        field.filterable = false;
+        field.sortable = false;
+        field.file = { image, accept, maxSize: maxSize ?? 0 };
+    }
+    if (isText) {
+        for (const key of ["minLength", "maxLength"]) {
+            const v = o[key];
+            if (v !== undefined) {
+                if (!Number.isInteger(v) || v < 0)
+                    issue(`${at}.${key}`, "must be a non-negative integer");
+                field.validation[key] = v;
+            }
+        }
+        if (o.pattern !== undefined) {
+            try {
+                new RegExp(o.pattern);
+                field.validation.pattern = o.pattern;
+            }
+            catch {
+                issue(`${at}.pattern`, "is not a valid regular expression");
+            }
+        }
+        if (kind === "string" && field.validation.maxLength === undefined)
+            field.validation.maxLength = 255;
+    }
+    if (isNumber) {
+        if (isComputed && (o.min !== undefined || o.max !== undefined))
+            issue(at, "computed fields have no min/max");
+        if (o.min !== undefined)
+            field.validation.min = o.min;
+        if (o.max !== undefined)
+            field.validation.max = o.max;
+        if (kind === "percentage") {
+            field.validation.min ??= 0;
+            field.validation.max ??= 100;
+        }
+        if (kind === "decimal" || kind === "money") {
+            field.precision = o.precision ?? (kind === "money" ? 19 : 18);
+            field.scale = o.scale ?? (kind === "money" ? 4 : 6);
+            if (field.scale > field.precision)
+                issue(`${at}.scale`, "cannot exceed precision");
+        }
+        if (kind === "money") {
+            field.currency = (o.currency ?? "USD").toUpperCase();
+            if (!/^[A-Z]{3}$/.test(field.currency))
+                issue(`${at}.currency`, "must be an ISO 4217 code such as USD");
+        }
+    }
+    if (kind === "enum") {
+        const raw = o.values;
+        const values = Array.isArray(raw)
+            ? raw.map((v) => ({ value: v, label: titleCase(v) }))
+            : raw && typeof raw === "object"
+                ? Object.entries(raw).map(([value, label]) => ({ value, label }))
+                : [];
+        if (values.length === 0)
+            issue(`${at}.values`, "enum fields need at least one value");
+        for (const v of values) {
+            if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(v.value))
+                issue(`${at}.values`, `"${v.value}" must start with a letter and contain only letters, digits or _`);
+        }
+        if (new Set(values.map((v) => v.value)).size !== values.length)
+            issue(`${at}.values`, "values must be unique");
+        field.enumValues = values;
+    }
+    if (isRelation) {
+        const target = o.entity;
+        const builtin = target ? BUILTIN_ENTITIES[target] : undefined;
+        const shell = target ? shells.get(target) : undefined;
+        if (!target)
+            issue(`${at}.entity`, "relation fields need a target entity");
+        else if (!builtin && !shell)
+            issue(`${at}.entity`, `unknown entity "${target}"`);
+        if (o.type && o.type !== "many-to-one" && o.type !== "many-to-many")
+            issue(`${at}.type`, `relation type must be "many-to-one" or "many-to-many"`);
+        if (isManyToMany) {
+            if (target === "Organization")
+                issue(`${at}.entity`, "many-to-many relations to Organization are not supported");
+            if (o.owner)
+                issue(`${at}.owner`, "the owner must be a many-to-one relation");
+            if (o.onDelete)
+                issue(`${at}.onDelete`, "many-to-many links are always removed with either side");
+        }
+        const onDelete = o.onDelete ?? (o.required ? "restrict" : "setNull");
+        if (!isManyToMany && onDelete === "setNull" && o.required)
+            issue(`${at}.onDelete`, `"setNull" requires an optional relation`);
+        field.apiName = isManyToMany ? `${singularize(name)}Ids` : `${name}Id`;
+        field.column = isManyToMany ? "" : `${snakeCase(name)}_id`;
+        if (isManyToMany)
+            field.sortable = false;
+        field.relation = {
+            type: isManyToMany ? "many-to-many" : "many-to-one",
+            entity: target ?? "",
+            model: builtin?.model ?? shell?.model ?? target ?? "",
+            delegate: builtin?.delegate ?? shell?.delegate ?? "",
+            ...(shell ? { path: shell.path } : {}),
+            builtin: !!builtin,
+            foreignKey: isManyToMany ? "" : `${name}Id`,
+            foreignKeyColumn: isManyToMany ? "" : `${snakeCase(name)}_id`,
+            onDelete: isManyToMany ? "cascade" : onDelete,
+            owner: !!o.owner,
+            inverse: o.inverse ?? "",
+            targetDisplay: builtin?.display ?? shell?.display ?? "id",
+        };
+    }
+    if (o.default !== undefined)
+        field.default = compileDefault(field, o.default, at, issue);
+    return field;
+}
+function compileDefault(field, value, at, issue) {
+    const bad = (expected) => {
+        issue(`${at}.default`, `expected ${expected}`);
+        return undefined;
+    };
+    switch (field.kind) {
+        case "relation":
+            return bad("no default on relation fields (owner relations default to the current user)");
+        case "location":
+        case "file":
+        case "image":
+            return bad(`no default on ${field.kind} fields`);
+        case "date":
+        case "datetime":
+            if (value === "now")
+                return { kind: "now" };
+            if (typeof value !== "string" || Number.isNaN(Date.parse(value)))
+                return bad(`"now" or an ISO date string`);
+            return { kind: "value", value };
+        case "boolean":
+            return typeof value === "boolean" ? { kind: "value", value } : bad("a boolean");
+        case "integer":
+            return Number.isInteger(value) ? { kind: "value", value: value } : bad("an integer");
+        case "decimal":
+        case "money":
+        case "percentage":
+            return typeof value === "number" ? { kind: "value", value } : bad("a number");
+        case "enum":
+            return field.enumValues?.some((v) => v.value === value) ? { kind: "value", value: value } : bad(`one of the enum values`);
+        case "json":
+            return { kind: "value", value: value };
+        default:
+            return typeof value === "string" ? { kind: "value", value } : bad("a string");
+    }
+}
+function isFieldDefinition(v) {
+    return !!v && typeof v === "object" && v.__forge === "field";
+}
+function pickDisplay(fields) {
+    const names = Object.keys(fields);
+    for (const preferred of ["name", "title", "label", "number", "code", "email"])
+        if (names.includes(preferred))
+            return preferred;
+    return names.find((n) => TEXT_KINDS.has(fields[n].kind)) ?? names.find((n) => fields[n].kind !== "relation") ?? "id";
+}
+function defaultColumns(fields, display, timestamps) {
+    const explicit = fields.filter((f) => f.list && !f.hidden).map((f) => f.name);
+    if (explicit.length > 0)
+        return uniq([display, ...explicit, ...(timestamps ? ["createdAt"] : [])]).filter((c) => c !== "id");
+    const picked = fields
+        .filter((f) => !f.hidden && !["text", "richtext", "json", "location", "file"].includes(f.kind) && f.name !== display)
+        .slice(0, 4)
+        .map((f) => f.name);
+    return uniq([display, ...picked, ...(timestamps ? ["createdAt"] : [])]).filter((c) => c !== "id");
+}
+export function parseSort(sort) {
+    return sort.startsWith("-") ? { field: sort.slice(1), direction: "desc" } : { field: sort.replace(/^\+/, ""), direction: "asc" };
+}
+function checkUnique(pairs, what, issue) {
+    const seen = new Map();
+    for (const [name, value] of pairs) {
+        const prev = seen.get(value);
+        if (prev)
+            issue(`entities.${name}`, `${what} "${value}" is already used by ${prev}`);
+        seen.set(value, name);
+    }
+}
+function uniq(xs) {
+    return [...new Set(xs)];
+}
+//# sourceMappingURL=compile.js.map