@vertebr/admin 0.1.0

package/dist/index.js

@@ -0,0 +1,650 @@
+"use strict";
+/**
+ * Vertebr — core admin control plane.
+ * Wire resources once; owners control them from the admin UI.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whereEq = exports.postgresJsonbTableDDL = exports.postgresAdapter = exports.mongoAdapter = exports.memoryAdapter = exports.firestoreAdapter = exports.databaseConnector = exports.adapterList = exports.adapterCount = exports.adapterConfigStore = exports.VertebrEnvError = exports.VertebrNotFoundError = exports.VertebrAuthError = exports.VERTEBR_ENV_HEADER = exports.mergeConfigValue = exports.memoryStore = void 0;
+exports.createAdmin = createAdmin;
+exports.stripeConnector = stripeConnector;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const store_1 = require("./store");
+var store_2 = require("./store");
+Object.defineProperty(exports, "memoryStore", { enumerable: true, get: function () { return store_2.memoryStore; } });
+Object.defineProperty(exports, "mergeConfigValue", { enumerable: true, get: function () { return store_2.mergeConfigValue; } });
+/** Header the dashboard sends to select the active environment. */
+exports.VERTEBR_ENV_HEADER = "x-vertebr-env";
+class VertebrAuthError extends Error {
+    statusCode = 401;
+    constructor(message = "Unauthorized") {
+        super(message);
+        this.name = "VertebrAuthError";
+    }
+}
+exports.VertebrAuthError = VertebrAuthError;
+class VertebrNotFoundError extends Error {
+    statusCode = 404;
+    constructor(message = "Not found") {
+        super(message);
+        this.name = "VertebrNotFoundError";
+    }
+}
+exports.VertebrNotFoundError = VertebrNotFoundError;
+class VertebrEnvError extends Error {
+    statusCode = 400;
+    constructor(message = "Invalid environment") {
+        super(message);
+        this.name = "VertebrEnvError";
+    }
+}
+exports.VertebrEnvError = VertebrEnvError;
+function defaultStaticDir() {
+    const candidate = node_path_1.default.join(__dirname, "..", "static");
+    if (node_fs_1.default.existsSync(node_path_1.default.join(candidate, "index.html"))) {
+        return candidate;
+    }
+    return undefined;
+}
+function contentTypeFor(filePath) {
+    const ext = node_path_1.default.extname(filePath).toLowerCase();
+    switch (ext) {
+        case ".html":
+            return "text/html; charset=utf-8";
+        case ".js":
+            return "text/javascript; charset=utf-8";
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".svg":
+            return "image/svg+xml";
+        case ".json":
+            return "application/json";
+        case ".png":
+            return "image/png";
+        case ".woff2":
+            return "font/woff2";
+        default:
+            return "application/octet-stream";
+    }
+}
+function headerValue(headers, name) {
+    if (!headers)
+        return undefined;
+    const raw = headers[name] ?? headers[name.toLowerCase()];
+    if (Array.isArray(raw))
+        return raw[0];
+    return typeof raw === "string" ? raw : undefined;
+}
+function createAdmin(options) {
+    const basePath = (options.basePath ?? "/admin").replace(/\/$/, "") || "/admin";
+    const apiBase = `${basePath}/api`;
+    const resources = [];
+    const configs = [];
+    let metricsDef = null;
+    const controlMeta = new Map();
+    const staticDir = options.staticDir ?? defaultStaticDir();
+    const environments = options.environments && options.environments.length > 0
+        ? options.environments
+        : [{ id: "default", label: "Default", tone: "neutral" }];
+    const defaultEnvironment = options.defaultEnvironment ?? environments[0]?.id ?? "default";
+    if (!environments.some((env) => env.id === defaultEnvironment)) {
+        throw new Error(`defaultEnvironment "${defaultEnvironment}" is not in environments`);
+    }
+    function resolveDefaults(schema, defaults, env) {
+        const fromSchema = {};
+        for (const [key, field] of Object.entries(schema)) {
+            if (field.default !== undefined) {
+                fromSchema[key] = field.default;
+            }
+        }
+        const fromDef = typeof defaults === "function" ? defaults(env) : (defaults ?? {});
+        return { ...fromSchema, ...fromDef };
+    }
+    function resolveEnv(request) {
+        const header = headerValue(request.headers, exports.VERTEBR_ENV_HEADER);
+        const env = (header ?? defaultEnvironment).trim();
+        if (!environments.some((item) => item.id === env)) {
+            throw new VertebrEnvError(`Unknown environment "${env}". Expected one of: ${environments
+                .map((item) => item.id)
+                .join(", ")}`);
+        }
+        return env;
+    }
+    function publicAuth(env) {
+        return {
+            required: Boolean(env.auth?.required),
+            ...(env.auth?.claimKey ? { claimKey: env.auth.claimKey } : {}),
+            ...(env.auth?.roles?.length ? { roles: [...env.auth.roles] } : {}),
+            ...(env.auth?.client ? { client: env.auth.client } : {}),
+        };
+    }
+    function claimSatisfied(claims, key, expected) {
+        const value = claims?.[key];
+        if (value == null)
+            return false;
+        if (Array.isArray(value)) {
+            return value.map(String).includes(expected);
+        }
+        if (typeof value === "string") {
+            return (value === expected ||
+                value
+                    .split(",")
+                    .map((part) => part.trim())
+                    .includes(expected));
+        }
+        return false;
+    }
+    async function assertAuth(request, envId) {
+        const environment = environments.find((item) => item.id === envId);
+        if (!environment) {
+            throw new VertebrEnvError(`Unknown environment "${envId}"`);
+        }
+        const user = options.auth.getUser
+            ? await options.auth.getUser(request)
+            : null;
+        const envAuth = environment.auth;
+        if (envAuth?.required) {
+            if (!user) {
+                throw new VertebrAuthError("Sign in required for this environment");
+            }
+            if (envAuth.claimKey) {
+                const expected = envAuth.claimIncludes ?? environment.id;
+                if (!claimSatisfied(user.claims, envAuth.claimKey, expected)) {
+                    throw new VertebrAuthError(`Missing claim ${envAuth.claimKey}=${expected} for environment "${environment.id}"`);
+                }
+            }
+            if (envAuth.roles?.length) {
+                const roles = user.roles ?? [];
+                const ok = envAuth.roles.some((role) => roles.includes(role));
+                if (!ok) {
+                    throw new VertebrAuthError(`Requires one of roles: ${envAuth.roles.join(", ")}`);
+                }
+            }
+        }
+        const allowed = await options.auth.check(request, {
+            env: envId,
+            user,
+            environment,
+        });
+        if (!allowed) {
+            throw new VertebrAuthError();
+        }
+    }
+    async function withEnvContext(request, run) {
+        const env = resolveEnv(request);
+        await assertAuth(request, env);
+        const ctx = { env, request };
+        const execute = () => Promise.resolve(run(ctx));
+        if (options.onEnvironment) {
+            return options.onEnvironment(env, execute);
+        }
+        return execute();
+    }
+    /** Public storefront reads — resolve env, no auth. */
+    async function withPublicEnvContext(request, run) {
+        const env = resolveEnv(request);
+        const ctx = { env, request };
+        const execute = () => Promise.resolve(run(ctx));
+        if (options.onEnvironment) {
+            return options.onEnvironment(env, execute);
+        }
+        return execute();
+    }
+    function findResource(id) {
+        const resource = resources.find((r) => r.id === id);
+        if (!resource) {
+            throw new VertebrNotFoundError(`Resource "${id}" not found`);
+        }
+        return resource;
+    }
+    function findConfig(id) {
+        const config = configs.find((c) => c.id === id);
+        if (!config) {
+            throw new VertebrNotFoundError(`Config "${id}" not found`);
+        }
+        return config;
+    }
+    async function readConfigValue(id, env) {
+        const meta = controlMeta.get(id);
+        if (meta) {
+            const stored = await meta.store.get(id, env);
+            return (0, store_1.mergeConfigValue)(resolveDefaults(meta.schema, meta.defaults, env), stored);
+        }
+        const config = findConfig(id);
+        return config.get({ env, request: null });
+    }
+    const bootstrapHandler = async () => ({
+        ok: true,
+        brand: "Vertebr",
+        defaultEnvironment,
+        environments: environments.map((env) => ({
+            id: env.id,
+            label: env.label,
+            tone: env.tone ?? "neutral",
+            auth: publicAuth(env),
+        })),
+    });
+    const catalogHandler = async (request) => withEnvContext(request, async (ctx) => ({
+        ok: true,
+        brand: "Vertebr",
+        environment: ctx.env,
+        environments: environments.map((env) => ({
+            id: env.id,
+            label: env.label,
+            tone: env.tone ?? "neutral",
+            auth: publicAuth(env),
+        })),
+        defaultEnvironment,
+        resources: resources.map((r) => ({
+            id: r.id,
+            label: r.label,
+            schema: r.schema,
+            permissions: {
+                create: r.permissions?.create ?? Boolean(r.create),
+                update: r.permissions?.update ?? Boolean(r.update),
+                delete: r.permissions?.delete ?? Boolean(r.remove),
+            },
+        })),
+        configs: configs.map((c) => ({
+            id: c.id,
+            label: c.label,
+            schema: c.schema,
+        })),
+        metrics: metricsDef
+            ? {
+                id: metricsDef.id ?? "overview",
+                label: metricsDef.label ?? "Overview",
+            }
+            : null,
+    }));
+    const listResourceHandler = async (request) => withEnvContext(request, async (ctx) => {
+        const id = request.params?.id;
+        if (!id) {
+            throw new VertebrNotFoundError("Missing resource id");
+        }
+        const resource = findResource(id);
+        const items = resource.list ? await resource.list(ctx) : [];
+        return {
+            id: resource.id,
+            label: resource.label,
+            schema: resource.schema,
+            environment: ctx.env,
+            permissions: {
+                create: resource.permissions?.create ?? Boolean(resource.create),
+                update: resource.permissions?.update ?? Boolean(resource.update),
+                delete: resource.permissions?.delete ?? Boolean(resource.remove),
+            },
+            actions: resource.actions
+                ? Object.fromEntries(Object.entries(resource.actions).map(([key, action]) => [
+                    key,
+                    { label: action.label, input: action.input ?? {} },
+                ]))
+                : {},
+            items,
+        };
+    });
+    const updateResourceHandler = async (request) => withEnvContext(request, async (ctx) => {
+        const id = request.params?.id;
+        const rowId = request.params?.rowId;
+        if (!id || !rowId) {
+            throw new VertebrNotFoundError("Missing resource or row id");
+        }
+        const resource = findResource(id);
+        if (!resource.update) {
+            throw new VertebrNotFoundError(`Resource "${id}" is not updatable`);
+        }
+        const payload = request.payload;
+        const value = payload && typeof payload === "object"
+            ? payload
+            : {};
+        const item = await resource.update(rowId, value, ctx);
+        return { ok: true, id, rowId, environment: ctx.env, item };
+    });
+    const createResourceHandler = async (request) => withEnvContext(request, async (ctx) => {
+        const id = request.params?.id;
+        if (!id) {
+            throw new VertebrNotFoundError("Missing resource id");
+        }
+        const resource = findResource(id);
+        if (!resource.create) {
+            throw new VertebrNotFoundError(`Resource "${id}" cannot create`);
+        }
+        const payload = request.payload;
+        const value = payload && typeof payload === "object"
+            ? payload
+            : {};
+        const item = await resource.create(value, ctx);
+        return { ok: true, id, environment: ctx.env, item };
+    });
+    const deleteResourceHandler = async (request) => withEnvContext(request, async (ctx) => {
+        const id = request.params?.id;
+        const rowId = request.params?.rowId;
+        if (!id || !rowId) {
+            throw new VertebrNotFoundError("Missing resource or row id");
+        }
+        const resource = findResource(id);
+        if (!resource.remove) {
+            throw new VertebrNotFoundError(`Resource "${id}" cannot delete`);
+        }
+        await resource.remove(rowId, ctx);
+        return { ok: true, id, rowId, environment: ctx.env };
+    });
+    const resourceActionHandler = async (request) => withEnvContext(request, async (ctx) => {
+        const id = request.params?.id;
+        const rowId = request.params?.rowId;
+        const actionId = request.params?.actionId;
+        if (!id || !rowId || !actionId) {
+            throw new VertebrNotFoundError("Missing resource, row, or action id");
+        }
+        const resource = findResource(id);
+        const action = resource.actions?.[actionId];
+        if (!action) {
+            throw new VertebrNotFoundError(`Action "${actionId}" not found`);
+        }
+        const row = resource.get
+            ? await resource.get(rowId, ctx)
+            : (await (resource.list?.(ctx) ?? [])).find((item) => String(item.id ?? "") === rowId ||
+                String(item.slug ?? "") === rowId ||
+                String(item.uid ?? "") === rowId ||
+                String(item.email ?? "") === rowId);
+        if (!row) {
+            throw new VertebrNotFoundError(`Row "${rowId}" not found`);
+        }
+        const payload = request.payload;
+        const input = payload && typeof payload === "object"
+            ? payload
+            : undefined;
+        const result = await action.run(row, input, ctx);
+        return { ok: true, id, rowId, actionId, environment: ctx.env, result };
+    });
+    const metricsHandler = async (request) => withEnvContext(request, async (ctx) => {
+        if (!metricsDef) {
+            return {
+                ok: true,
+                id: "overview",
+                label: "Overview",
+                environment: ctx.env,
+                metrics: [],
+            };
+        }
+        const metrics = await metricsDef.load(ctx);
+        return {
+            ok: true,
+            id: metricsDef.id ?? "overview",
+            label: metricsDef.label ?? "Overview",
+            environment: ctx.env,
+            metrics,
+        };
+    });
+    const getConfigHandler = async (request) => withEnvContext(request, async (ctx) => {
+        const id = request.params?.id;
+        if (!id) {
+            throw new VertebrNotFoundError("Missing config id");
+        }
+        const config = findConfig(id);
+        const value = await config.get(ctx);
+        return {
+            id: config.id,
+            label: config.label,
+            schema: config.schema,
+            environment: ctx.env,
+            value,
+        };
+    });
+    const setConfigHandler = async (request) => withEnvContext(request, async (ctx) => {
+        const id = request.params?.id;
+        if (!id) {
+            throw new VertebrNotFoundError("Missing config id");
+        }
+        const config = findConfig(id);
+        const payload = request.payload;
+        const value = payload && typeof payload === "object"
+            ? payload
+            : {};
+        await config.set(value, ctx);
+        return {
+            ok: true,
+            id: config.id,
+            environment: ctx.env,
+            value: await config.get(ctx),
+        };
+    });
+    const publicControlsHandler = async (request) => withPublicEnvContext(request, async (ctx) => {
+        const entries = await Promise.all([...controlMeta.entries()]
+            .filter(([, meta]) => meta.public)
+            .map(async ([id]) => {
+            const value = await readConfigValue(id, ctx.env);
+            return [id, value];
+        }));
+        return {
+            ok: true,
+            environment: ctx.env,
+            configs: Object.fromEntries(entries),
+        };
+    });
+    const publicConfigHandler = async (request) => withPublicEnvContext(request, async (ctx) => {
+        const id = request.params?.id;
+        if (!id) {
+            throw new VertebrNotFoundError("Missing config id");
+        }
+        const meta = controlMeta.get(id);
+        if (!meta?.public) {
+            throw new VertebrNotFoundError(`Public control "${id}" not found`);
+        }
+        const config = findConfig(id);
+        return {
+            ok: true,
+            id,
+            label: config.label,
+            environment: ctx.env,
+            value: await readConfigValue(id, ctx.env),
+        };
+    });
+    const admin = {
+        resource(def) {
+            resources.push(def);
+            return admin;
+        },
+        config(def) {
+            configs.push(def);
+            return admin;
+        },
+        control(def) {
+            controlMeta.set(def.id, {
+                public: Boolean(def.public),
+                store: def.store,
+                defaults: def.defaults,
+                schema: def.schema,
+            });
+            configs.push({
+                id: def.id,
+                label: def.label,
+                schema: def.schema,
+                get: async (ctx) => readConfigValue(def.id, ctx.env),
+                set: async (value, ctx) => {
+                    const next = (0, store_1.mergeConfigValue)(resolveDefaults(def.schema, def.defaults, ctx.env), await def.store.get(def.id, ctx.env), value);
+                    await def.store.set(def.id, ctx.env, next);
+                },
+            });
+            return admin;
+        },
+        metrics(def) {
+            metricsDef = def;
+            return admin;
+        },
+        async readConfig(id, env) {
+            if (!environments.some((item) => item.id === env)) {
+                throw new VertebrEnvError(`Unknown environment "${env}"`);
+            }
+            const run = () => readConfigValue(id, env);
+            if (options.onEnvironment) {
+                return options.onEnvironment(env, run);
+            }
+            return run();
+        },
+        use(connector) {
+            connector.register(admin);
+            return admin;
+        },
+        routes() {
+            return [
+                {
+                    method: "GET",
+                    path: `${apiBase}/bootstrap`,
+                    handler: bootstrapHandler,
+                },
+                {
+                    method: "GET",
+                    path: `${apiBase}/public/controls`,
+                    handler: publicControlsHandler,
+                },
+                {
+                    method: "GET",
+                    path: `${apiBase}/public/configs/{id}`,
+                    handler: publicConfigHandler,
+                },
+                {
+                    method: "GET",
+                    path: `${apiBase}/metrics`,
+                    handler: metricsHandler,
+                },
+                { method: "GET", path: apiBase, handler: catalogHandler },
+                {
+                    method: "GET",
+                    path: `${apiBase}/resources/{id}`,
+                    handler: listResourceHandler,
+                },
+                {
+                    method: "POST",
+                    path: `${apiBase}/resources/{id}`,
+                    handler: createResourceHandler,
+                },
+                {
+                    method: "PUT",
+                    path: `${apiBase}/resources/{id}/{rowId}`,
+                    handler: updateResourceHandler,
+                },
+                {
+                    method: "DELETE",
+                    path: `${apiBase}/resources/{id}/{rowId}`,
+                    handler: deleteResourceHandler,
+                },
+                {
+                    method: "POST",
+                    path: `${apiBase}/resources/{id}/{rowId}/actions/{actionId}`,
+                    handler: resourceActionHandler,
+                },
+                {
+                    method: "GET",
+                    path: `${apiBase}/configs/{id}`,
+                    handler: getConfigHandler,
+                },
+                {
+                    method: "PUT",
+                    path: `${apiBase}/configs/{id}`,
+                    handler: setConfigHandler,
+                },
+            ];
+        },
+        hapiRoutes() {
+            const apiRoutes = admin.routes().map((route) => ({
+                method: route.method,
+                path: route.path,
+                options: { auth: false },
+                handler: async (request, h) => {
+                    const toolkit = h;
+                    try {
+                        return await route.handler(request);
+                    }
+                    catch (error) {
+                        if (error instanceof VertebrAuthError ||
+                            error instanceof VertebrNotFoundError ||
+                            error instanceof VertebrEnvError) {
+                            return toolkit
+                                .response({ ok: false, error: error.message })
+                                .code(error.statusCode);
+                        }
+                        throw error;
+                    }
+                },
+            }));
+            if (!staticDir) {
+                return apiRoutes;
+            }
+            const spaHandler = async (request, h) => {
+                const toolkit = h;
+                const req = request;
+                const reqPath = req.path ?? req.url?.pathname ?? "";
+                const relative = reqPath.slice(basePath.length).replace(/^\//, "");
+                if (relative === "api" || relative.startsWith("api/")) {
+                    return toolkit.response({ ok: false, error: "Not found" }).code(404);
+                }
+                const safeRelative = relative.replace(/\.\./g, "");
+                const candidate = node_path_1.default.join(staticDir, safeRelative === "" ? "index.html" : safeRelative);
+                const resolved = node_path_1.default.resolve(candidate);
+                if (!resolved.startsWith(node_path_1.default.resolve(staticDir))) {
+                    return toolkit.response({ ok: false, error: "Forbidden" }).code(403);
+                }
+                let filePath = resolved;
+                if (!node_fs_1.default.existsSync(filePath) || node_fs_1.default.statSync(filePath).isDirectory()) {
+                    filePath = node_path_1.default.join(staticDir, "index.html");
+                }
+                const body = node_fs_1.default.readFileSync(filePath);
+                return toolkit.response(body).type(contentTypeFor(filePath)).code(200);
+            };
+            const staticRoutes = [
+                {
+                    method: "GET",
+                    path: basePath,
+                    options: { auth: false },
+                    handler: spaHandler,
+                },
+                {
+                    method: "GET",
+                    path: `${basePath}/{path*}`,
+                    options: { auth: false },
+                    handler: spaHandler,
+                },
+            ];
+            return [...apiRoutes, ...staticRoutes];
+        },
+        resources: () => [...resources],
+        configs: () => [...configs],
+        environments: () => [...environments],
+    };
+    return admin;
+}
+/** Example connector shape — Stripe implementation TBD. */
+function stripeConnector(options) {
+    return {
+        id: options.id ?? "stripe",
+        register(admin) {
+            admin.resource({
+                id: "stripe-sessions",
+                label: "Stripe sessions",
+                schema: {
+                    id: { type: "string", readOnly: true },
+                    status: { type: "string", readOnly: true },
+                    amountTotal: { type: "number", readOnly: true },
+                },
+                list: async () => [],
+                permissions: { create: false, update: false, delete: false },
+            });
+        },
+    };
+}
+var database_1 = require("./database");
+Object.defineProperty(exports, "adapterConfigStore", { enumerable: true, get: function () { return database_1.adapterConfigStore; } });
+Object.defineProperty(exports, "adapterCount", { enumerable: true, get: function () { return database_1.adapterCount; } });
+Object.defineProperty(exports, "adapterList", { enumerable: true, get: function () { return database_1.adapterList; } });
+Object.defineProperty(exports, "databaseConnector", { enumerable: true, get: function () { return database_1.databaseConnector; } });
+Object.defineProperty(exports, "firestoreAdapter", { enumerable: true, get: function () { return database_1.firestoreAdapter; } });
+Object.defineProperty(exports, "memoryAdapter", { enumerable: true, get: function () { return database_1.memoryAdapter; } });
+Object.defineProperty(exports, "mongoAdapter", { enumerable: true, get: function () { return database_1.mongoAdapter; } });
+Object.defineProperty(exports, "postgresAdapter", { enumerable: true, get: function () { return database_1.postgresAdapter; } });
+Object.defineProperty(exports, "postgresJsonbTableDDL", { enumerable: true, get: function () { return database_1.postgresJsonbTableDDL; } });
+Object.defineProperty(exports, "whereEq", { enumerable: true, get: function () { return database_1.whereEq; } });
+//# sourceMappingURL=index.js.map