@vertebr/admin 0.4.0 → 0.5.0

package/dist/index.js

@@ -3,964 +3,30 @@
  * 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.VertebrBadRequestError = 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;
-class VertebrBadRequestError extends Error {
-    statusCode = 400;
-    constructor(message = "Bad request") {
-        super(message);
-        this.name = "VertebrBadRequestError";
-    }
-}
-exports.VertebrBadRequestError = VertebrBadRequestError;
-const DEFAULT_UPLOAD_ACCEPT = ["image/*"];
-const DEFAULT_UPLOAD_MAX_BYTES = 5_000_000;
-function publicUploads(resource) {
-    if (!resource.uploads)
-        return undefined;
-    const entries = Object.entries(resource.uploads).map(([field, def]) => [
-        field,
-        {
-            field,
-            accept: def.accept?.length ? def.accept : DEFAULT_UPLOAD_ACCEPT,
-            maxBytes: def.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES,
-        },
-    ]);
-    return entries.length > 0
-        ? Object.fromEntries(entries)
-        : undefined;
-}
-function mimeAllowed(type, accept) {
-    if (accept.length === 0)
-        return true;
-    const normalized = type.toLowerCase() || "application/octet-stream";
-    return accept.some((rule) => {
-        const pattern = rule.toLowerCase().trim();
-        if (!pattern || pattern === "*/*")
-            return true;
-        if (pattern.endsWith("/*")) {
-            return normalized.startsWith(pattern.slice(0, -1));
-        }
-        return normalized === pattern;
-    });
-}
-function decodeUploadPayload(entry) {
-    if (!entry || typeof entry !== "object") {
-        throw new VertebrBadRequestError("Invalid upload payload");
-    }
-    const body = entry;
-    const name = typeof body.name === "string" ? body.name.trim() : "";
-    const type = typeof body.type === "string" && body.type.trim()
-        ? body.type.trim()
-        : "application/octet-stream";
-    const data = typeof body.data === "string" ? body.data : "";
-    if (!name) {
-        throw new VertebrBadRequestError("Upload is missing a file name");
-    }
-    if (!data) {
-        throw new VertebrBadRequestError("Upload is missing file data");
-    }
-    const base64 = data.includes(",") ? data.slice(data.indexOf(",") + 1) : data;
-    let buffer;
-    try {
-        buffer = Buffer.from(base64, "base64");
-    }
-    catch {
-        throw new VertebrBadRequestError("Upload data is not valid base64");
-    }
-    if (!buffer.length) {
-        throw new VertebrBadRequestError("Upload file is empty");
-    }
-    return { name, type, size: buffer.byteLength, buffer };
-}
-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;
-    let galleryDef = 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),
-            },
-            uploads: publicUploads(r),
-        })),
-        configs: configs.map((c) => ({
-            id: c.id,
-            label: c.label,
-            schema: c.schema,
-            section: c.section === "page" ? "page" : "config",
-        })),
-        metrics: metricsDef
-            ? {
-                id: metricsDef.id ?? "overview",
-                label: metricsDef.label ?? "Overview",
-            }
-            : null,
-        gallery: galleryDef
-            ? {
-                id: galleryDef.id ?? "gallery",
-                label: galleryDef.label ?? "Gallery",
-                accept: galleryDef.accept?.length
-                    ? galleryDef.accept
-                    : DEFAULT_UPLOAD_ACCEPT,
-                maxBytes: galleryDef.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES,
-                canDelete: Boolean(galleryDef.remove),
-            }
-            : 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 ?? {} },
-                ]))
-                : {},
-            uploads: publicUploads(resource),
-            items,
-        };
-    });
-    const runFieldUpload = async (resource, field, file, ctx) => {
-        const def = resource.uploads?.[field];
-        if (!def) {
-            throw new VertebrNotFoundError(`Upload is not configured for field "${field}"`);
-        }
-        const accept = def.accept?.length ? def.accept : DEFAULT_UPLOAD_ACCEPT;
-        const maxBytes = def.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-        if (file.size > maxBytes) {
-            throw new VertebrBadRequestError(`File exceeds max size of ${maxBytes} bytes`);
-        }
-        if (!mimeAllowed(file.type, accept)) {
-            throw new VertebrBadRequestError(`File type "${file.type}" is not allowed`);
-        }
-        const result = await def.upload(file, ctx);
-        if (!result?.url || typeof result.url !== "string") {
-            throw new VertebrBadRequestError("Upload handler did not return a url");
-        }
-        return { url: result.url, name: result.name ?? file.name };
-    };
-    const uploadResourceFileHandler = async (request) => withEnvContext(request, async (ctx) => {
-        const id = request.params?.id;
-        const field = request.params?.field;
-        if (!id || !field) {
-            throw new VertebrNotFoundError("Missing resource or field");
-        }
-        const resource = findResource(id);
-        const file = decodeUploadPayload(request.payload);
-        const result = await runFieldUpload(resource, field, file, ctx);
-        return { ok: true, id, field, environment: ctx.env, ...result };
-    });
-    const uploadResourceFilesHandler = async (request) => withEnvContext(request, async (ctx) => {
-        const id = request.params?.id;
-        const field = request.params?.field;
-        if (!id || !field) {
-            throw new VertebrNotFoundError("Missing resource or field");
-        }
-        const resource = findResource(id);
-        const payload = request.payload;
-        const list = payload &&
-            typeof payload === "object" &&
-            Array.isArray(payload.files)
-            ? payload.files
-            : null;
-        if (!list?.length) {
-            throw new VertebrBadRequestError("Provide files: [] for bulk upload");
-        }
-        if (list.length > 40) {
-            throw new VertebrBadRequestError("Bulk upload is limited to 40 files");
-        }
-        const files = [];
-        for (const entry of list) {
-            const file = decodeUploadPayload(entry);
-            files.push(await runFieldUpload(resource, field, file, ctx));
-        }
-        return { ok: true, id, field, environment: ctx.env, files };
-    });
-    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 requireGallery = () => {
-        if (!galleryDef) {
-            throw new VertebrNotFoundError("Gallery is not configured");
-        }
-        return galleryDef;
-    };
-    const runGalleryUpload = async (file, ctx) => {
-        const gallery = requireGallery();
-        const accept = gallery.accept?.length
-            ? gallery.accept
-            : DEFAULT_UPLOAD_ACCEPT;
-        const maxBytes = gallery.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-        if (file.size > maxBytes) {
-            throw new VertebrBadRequestError(`File exceeds max size of ${maxBytes} bytes`);
-        }
-        if (!mimeAllowed(file.type, accept)) {
-            throw new VertebrBadRequestError(`File type "${file.type}" is not allowed`);
-        }
-        const item = await gallery.upload(file, ctx);
-        if (!item?.id || !item?.url) {
-            throw new VertebrBadRequestError("Gallery upload must return an item with id and url");
-        }
-        return item;
-    };
-    const listGalleryHandler = async (request) => withEnvContext(request, async (ctx) => {
-        const gallery = requireGallery();
-        const items = await gallery.list(ctx);
-        return {
-            ok: true,
-            id: gallery.id ?? "gallery",
-            label: gallery.label ?? "Gallery",
-            environment: ctx.env,
-            accept: gallery.accept?.length
-                ? gallery.accept
-                : DEFAULT_UPLOAD_ACCEPT,
-            maxBytes: gallery.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES,
-            canDelete: Boolean(gallery.remove),
-            items,
-        };
-    });
-    const uploadGalleryFileHandler = async (request) => withEnvContext(request, async (ctx) => {
-        const file = decodeUploadPayload(request.payload);
-        const item = await runGalleryUpload(file, ctx);
-        return { ok: true, environment: ctx.env, item };
-    });
-    const uploadGalleryFilesHandler = async (request) => withEnvContext(request, async (ctx) => {
-        const payload = request.payload;
-        const list = payload &&
-            typeof payload === "object" &&
-            Array.isArray(payload.files)
-            ? payload.files
-            : null;
-        if (!list?.length) {
-            throw new VertebrBadRequestError("Provide files: [] for bulk upload");
-        }
-        if (list.length > 40) {
-            throw new VertebrBadRequestError("Bulk upload is limited to 40 files");
-        }
-        const items = [];
-        for (const entry of list) {
-            items.push(await runGalleryUpload(decodeUploadPayload(entry), ctx));
-        }
-        return { ok: true, environment: ctx.env, items };
-    });
-    const deleteGalleryItemHandler = async (request) => withEnvContext(request, async (ctx) => {
-        const gallery = requireGallery();
-        const itemId = request.params?.itemId;
-        if (!itemId) {
-            throw new VertebrNotFoundError("Missing gallery item id");
-        }
-        if (!gallery.remove) {
-            throw new VertebrNotFoundError("Gallery delete is not configured");
-        }
-        await gallery.remove(itemId, ctx);
-        return { ok: true, id: itemId, environment: ctx.env };
-    });
-    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 publicResourceHandler = async (request) => withPublicEnvContext(request, async (ctx) => {
-        const id = request.params?.id;
-        if (!id) {
-            throw new VertebrNotFoundError("Missing resource id");
-        }
-        const resource = findResource(id);
-        if (!resource.public) {
-            throw new VertebrNotFoundError(`Public resource "${id}" not found`);
-        }
-        const listed = resource.list ? await resource.list(ctx) : [];
-        const items = listed.filter((row) => {
-            if (!row || typeof row !== "object")
-                return false;
-            return row.active !== false;
-        });
-        return {
-            ok: true,
-            id: resource.id,
-            environment: ctx.env,
-            items,
-        };
-    });
-    const admin = {
-        resource(def) {
-            resources.push(def);
-            return admin;
-        },
-        config(def) {
-            configs.push({
-                ...def,
-                section: def.section === "page" ? "page" : "config",
-            });
-            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,
-                section: def.section === "page" ? "page" : "config",
-                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;
-        },
-        page(def) {
-            return admin.control({ ...def, section: "page" });
-        },
-        layout(def) {
-            const slotIds = def.slots.map((slot) => slot.id);
-            const order = def.defaultOrder?.filter((id) => slotIds.includes(id)) ?? slotIds;
-            const optionLabels = Object.fromEntries(def.slots.map((slot) => [slot.id, slot.label]));
-            const presets = def.presets ?? [];
-            const presetIds = presets.map((preset) => preset.id);
-            const presetLabels = Object.fromEntries(presets.map((preset) => [preset.id, preset.label]));
-            return admin.control({
-                id: def.id,
-                label: def.label,
-                public: def.public,
-                store: def.store,
-                section: def.section === "config" ? "config" : "page",
-                defaults: {
-                    ...(presetIds[0] ? { preset: presetIds[0] } : {}),
-                    blocks: order,
-                },
-                schema: {
-                    ...(presetIds.length
-                        ? {
-                            preset: {
-                                type: "enum",
-                                label: "Preset",
-                                options: presetIds,
-                                optionLabels: presetLabels,
-                                default: presetIds[0],
-                                group: "Layout",
-                            },
-                        }
-                        : {}),
-                    blocks: {
-                        type: "enum[]",
-                        label: "Blocks",
-                        options: slotIds,
-                        optionLabels,
-                        default: order,
-                        group: "Layout",
-                    },
-                },
-            });
-        },
-        metrics(def) {
-            metricsDef = def;
-            return admin;
-        },
-        gallery(def) {
-            galleryDef = 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}/public/resources/{id}`,
-                    handler: publicResourceHandler,
-                },
-                {
-                    method: "GET",
-                    path: `${apiBase}/metrics`,
-                    handler: metricsHandler,
-                },
-                {
-                    method: "GET",
-                    path: `${apiBase}/gallery`,
-                    handler: listGalleryHandler,
-                },
-                {
-                    method: "POST",
-                    path: `${apiBase}/gallery/upload`,
-                    handler: uploadGalleryFileHandler,
-                },
-                {
-                    method: "POST",
-                    path: `${apiBase}/gallery/upload/bulk`,
-                    handler: uploadGalleryFilesHandler,
-                },
-                {
-                    method: "DELETE",
-                    path: `${apiBase}/gallery/{itemId}`,
-                    handler: deleteGalleryItemHandler,
-                },
-                { 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: "POST",
-                    path: `${apiBase}/resources/{id}/uploads/{field}`,
-                    handler: uploadResourceFileHandler,
-                },
-                {
-                    method: "POST",
-                    path: `${apiBase}/resources/{id}/uploads/{field}/bulk`,
-                    handler: uploadResourceFilesHandler,
-                },
-                {
-                    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 ||
-                            error instanceof VertebrBadRequestError) {
-                            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 },
-            });
-        },
-    };
-}
+exports.whereEq = exports.postgresJsonbTableDDL = exports.postgresAdapter = exports.mongoAdapter = exports.memoryAdapter = exports.firestoreAdapter = exports.databaseConnector = exports.adapterList = exports.adapterCount = exports.adapterConfigStore = exports.toMailDiscountOptions = exports.stripePaymentsProvider = exports.paymentsConnector = exports.stripeConnector = exports.createAdmin = exports.VertebrNotFoundError = exports.VertebrEnvError = exports.VertebrBadRequestError = exports.VertebrAuthError = exports.resolveMetricsRange = exports.parseMetricsRange = exports.METRICS_RANGES = exports.VERTEBR_ENV_HEADER = exports.mergeConfigValue = exports.memoryStore = void 0;
+var store_1 = require("./store");
+Object.defineProperty(exports, "memoryStore", { enumerable: true, get: function () { return store_1.memoryStore; } });
+Object.defineProperty(exports, "mergeConfigValue", { enumerable: true, get: function () { return store_1.mergeConfigValue; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "VERTEBR_ENV_HEADER", { enumerable: true, get: function () { return constants_1.VERTEBR_ENV_HEADER; } });
+var metricsRange_1 = require("./utils/metricsRange");
+Object.defineProperty(exports, "METRICS_RANGES", { enumerable: true, get: function () { return metricsRange_1.METRICS_RANGES; } });
+Object.defineProperty(exports, "parseMetricsRange", { enumerable: true, get: function () { return metricsRange_1.parseMetricsRange; } });
+Object.defineProperty(exports, "resolveMetricsRange", { enumerable: true, get: function () { return metricsRange_1.resolveMetricsRange; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "VertebrAuthError", { enumerable: true, get: function () { return errors_1.VertebrAuthError; } });
+Object.defineProperty(exports, "VertebrBadRequestError", { enumerable: true, get: function () { return errors_1.VertebrBadRequestError; } });
+Object.defineProperty(exports, "VertebrEnvError", { enumerable: true, get: function () { return errors_1.VertebrEnvError; } });
+Object.defineProperty(exports, "VertebrNotFoundError", { enumerable: true, get: function () { return errors_1.VertebrNotFoundError; } });
+var createAdmin_1 = require("./createAdmin");
+Object.defineProperty(exports, "createAdmin", { enumerable: true, get: function () { return createAdmin_1.createAdmin; } });
+var stripe_1 = require("./connectors/stripe");
+Object.defineProperty(exports, "stripeConnector", { enumerable: true, get: function () { return stripe_1.stripeConnector; } });
+var payments_1 = require("./connectors/payments");
+Object.defineProperty(exports, "paymentsConnector", { enumerable: true, get: function () { return payments_1.paymentsConnector; } });
+Object.defineProperty(exports, "stripePaymentsProvider", { enumerable: true, get: function () { return payments_1.stripePaymentsProvider; } });
+Object.defineProperty(exports, "toMailDiscountOptions", { enumerable: true, get: function () { return payments_1.toMailDiscountOptions; } });
 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; } });