@databob/sdk 0.0.0-stage → 0.0.1

package/dist/cli.js

@@ -0,0 +1,355 @@
+#!/usr/bin/env node
+// databob CLI. Every command prints JSON or plain lines, so agents can drive it.
+import { existsSync, readFileSync, watch } from "node:fs";
+import { createServer } from "node:http";
+import { join, relative } from "node:path";
+import { parseEnv } from "node:util";
+import { Engine, EngineError, createHandler } from "@databob/engine";
+import { LocalTenants, StaticProjects, toNodeListener } from "@databob/engine/node";
+import { ProjectLoadError, codegen, devState, loadProject, paths, projectConfig, scaffold, writeEnv, } from "./project.js";
+const HELP = `databob: typed analytics you define in code
+
+Usage: databob <command> [options]
+
+  init                         Create databob/schema.ts and databob/metrics.ts
+  dev [--port 4100]            Run the local API, watch databob/, regenerate types
+  start [--port 4100]          Self-host in production. Needs DATABOB_SECRET_KEY,
+                               DATABOB_SIGNING_KEY, DATABOB_USER_KEY (32+ chars each)
+  check                        Validate the schema and every metric (exit 1 on problems)
+  deploy [--url URL]           Ship databob/ to databob cloud. Needs DATABOB_URL and
+                               DATABOB_DEPLOY_KEY (environment or .env.local)
+  codegen                      Write databob/_generated
+  describe                     Print the schema and metrics as JSON
+  query <metric> [options]     Run a metric on local data and print JSON
+      --args '{"range":"7d"}'  --tenant <id>  --tz <IANA zone>  --compare
+  track <event> [options]      Record one event locally
+      --props '{"plan":"pro"}' --tenant <id>  --user <id>
+
+Data lives in .databob/ (git-ignored). Requires Node 22.13+.`;
+function parse(argv) {
+    const flags = { _: [] };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (!arg.startsWith("--")) {
+            flags._.push(arg);
+            continue;
+        }
+        const [name, inline] = arg.slice(2).split("=", 2);
+        if (inline !== undefined)
+            flags[name] = inline;
+        else if (argv[index + 1] !== undefined && !argv[index + 1].startsWith("--"))
+            flags[name] = argv[++index];
+        else
+            flags[name] = true;
+    }
+    return flags;
+}
+function str(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+function jsonFlag(flags, name) {
+    const value = str(flags, name);
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error(`--${name} must be JSON, for example --${name} '{"range":"7d"}'`);
+    }
+}
+function print(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+async function loadOrExit(p) {
+    const loaded = await loadProject(p);
+    if (loaded.problems.length > 0) {
+        for (const problem of loaded.problems)
+            console.error(`✗ ${problem}`);
+        process.exit(1);
+    }
+    return loaded;
+}
+async function local(p) {
+    const loaded = await loadOrExit(p);
+    const tenants = new LocalTenants({ dir: p.data });
+    return { engine: new Engine(tenants), project: projectConfig(devState(p), loaded), tenants };
+}
+const MIN_KEY_LENGTH = 32;
+function requiredSecret(name) {
+    const value = process.env[name] ?? "";
+    if (value.length < MIN_KEY_LENGTH) {
+        console.error(`✗ Set ${name} to a random value of at least ${MIN_KEY_LENGTH} characters.`);
+        process.exit(1);
+    }
+    return value;
+}
+// Production self-hosting: no file watching, no generated keys, no .env writes.
+async function start(p, flags) {
+    const port = Number(str(flags, "port") ?? process.env.PORT ?? process.env.DATABOB_PORT ?? 4100);
+    const host = str(flags, "host") ?? process.env.DATABOB_HOST ?? "0.0.0.0";
+    const secretKey = requiredSecret("DATABOB_SECRET_KEY");
+    if (!secretKey.startsWith("dbsk_")) {
+        console.error("✗ DATABOB_SECRET_KEY must start with dbsk_");
+        process.exit(1);
+    }
+    const loaded = await loadOrExit(p);
+    const config = {
+        id: process.env.DATABOB_PROJECT_ID ?? "default",
+        schema: loaded.schema,
+        metrics: loaded.metrics,
+        signingKey: requiredSecret("DATABOB_SIGNING_KEY"),
+        userKey: requiredSecret("DATABOB_USER_KEY"),
+    };
+    const tenants = new LocalTenants({ dir: process.env.DATABOB_DATA_DIR ?? p.data });
+    const handler = createHandler({ projects: new StaticProjects([{ secretKey, config }]), engine: new Engine(tenants) });
+    const server = createServer(toNodeListener(handler));
+    server.listen(port, host, () => {
+        console.log(`databob listening on http://${host}:${port} (${Object.keys(config.metrics).length} metrics)`);
+    });
+    const stop = () => {
+        server.close(() => {
+            tenants.close();
+            process.exit(0);
+        });
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+}
+// Reads .env.local and .env without overriding variables already set.
+function loadEnvFiles(root) {
+    for (const name of [".env.local", ".env"]) {
+        const file = join(root, name);
+        if (!existsSync(file))
+            continue;
+        const parsed = parseEnv(readFileSync(file, "utf8"));
+        for (const [key, value] of Object.entries(parsed)) {
+            if (process.env[key] === undefined && value !== undefined)
+                process.env[key] = value;
+        }
+    }
+}
+async function deploy(p, flags) {
+    loadEnvFiles(p.root);
+    const url = (str(flags, "url") ?? process.env.DATABOB_URL ?? "").replace(/\/+$/, "");
+    const key = process.env.DATABOB_DEPLOY_KEY ?? "";
+    if (url === "" || /^https?:\/\/(127\.0\.0\.1|localhost)(:|\/|$)/.test(url)) {
+        console.error("✗ Set DATABOB_URL to your databob cloud URL. `databob dev` reloads by itself and needs no deploy.");
+        process.exit(1);
+    }
+    if (!key.startsWith("dbdk_")) {
+        console.error("✗ Set DATABOB_DEPLOY_KEY to the app's deploy key (dbdk_...). The dashboard shows it once.");
+        process.exit(1);
+    }
+    const loaded = await loadOrExit(p);
+    let response;
+    try {
+        response = await fetch(`${url}/v1/deploy`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+            body: JSON.stringify({ schema: loaded.schema, metrics: loaded.metrics }),
+        });
+    }
+    catch (error) {
+        console.error(`✗ Could not reach ${url}: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        console.error(`✗ Deploy failed (${response.status}): ${body.message ?? response.statusText}`);
+        for (const problem of body.problems ?? [])
+            console.error(`  ✗ ${problem}`);
+        process.exit(1);
+    }
+    console.log(`✓ Deployed version ${body.version}: ${body.events} event(s), ${body.metrics} metric(s) to ${url}`);
+}
+async function dev(p, flags) {
+    const port = Number(str(flags, "port") ?? process.env.DATABOB_PORT ?? 4100);
+    const host = str(flags, "host") ?? "127.0.0.1";
+    if (scaffold(p).length > 0)
+        console.log(`Created ${relative(process.cwd(), p.source)}/ with a starter schema and metrics.`);
+    const state = devState(p);
+    let loaded;
+    try {
+        loaded = await loadProject(p);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+    for (const problem of loaded.problems)
+        console.error(`✗ ${problem}`);
+    const projects = new StaticProjects([{ secretKey: state.secretKey, config: projectConfig(state, loaded) }]);
+    const tenants = new LocalTenants({ dir: p.data });
+    const handler = createHandler({ projects, engine: new Engine(tenants) });
+    const server = createServer(toNodeListener(async (request) => {
+        const url = new URL(request.url);
+        if (url.pathname === "/") {
+            const config = await projects.byId(state.projectId);
+            return Response.json({
+                name: "databob dev",
+                project: state.projectId,
+                events: Object.keys(config?.schema.events ?? {}),
+                metrics: Object.keys(config?.metrics ?? {}),
+                routes: ["POST /v1/track", "POST /v1/metrics/:name", "GET /v1/metrics/:name/live", "POST /v1/query", "POST /v1/tokens", "GET /v1/describe"],
+            });
+        }
+        return handler(request);
+    }));
+    server.on("error", (error) => {
+        console.error(error.code === "EADDRINUSE" ? `Port ${port} is in use. Try --port ${port + 1}.` : error.message);
+        process.exit(1);
+    });
+    server.listen(port, host, () => {
+        const url = `http://${host}:${port}`;
+        const added = writeEnv(p, url, state.secretKey);
+        const events = Object.keys(loaded.schema.events).length;
+        const metrics = Object.keys(loaded.metrics).length;
+        console.log(`databob dev  ${url}`);
+        console.log(`  project  ${state.projectId}: ${events} event(s), ${metrics} metric(s)${loaded.schema.tenants ? ", tenants on" : ""}`);
+        console.log(`  data     ${relative(process.cwd(), p.data) || "."}`);
+        console.log(`  secret   ${state.secretKey}`);
+        if (added.length > 0)
+            console.log(`  env      added ${added.join(", ")} to .env.local`);
+        console.log(`Watching ${relative(process.cwd(), p.source)}/ for changes.`);
+    });
+    let timer = null;
+    const reload = async () => {
+        try {
+            const next = await loadProject(p);
+            if (next.problems.length > 0) {
+                for (const problem of next.problems)
+                    console.error(`✗ ${problem}`);
+                console.error("Keeping the previous schema and metrics until these are fixed.");
+                return;
+            }
+            projects.replace([{ secretKey: state.secretKey, config: projectConfig(state, next) }]);
+            loaded = next;
+            console.log(`✓ Reloaded: ${Object.keys(next.schema.events).length} event(s), ${Object.keys(next.metrics).length} metric(s)`);
+        }
+        catch (error) {
+            console.error(`✗ ${error instanceof Error ? error.message : error}`);
+            console.error("Keeping the previous schema and metrics until this is fixed.");
+        }
+    };
+    watch(p.source, { recursive: true }, (_event, file) => {
+        if (!file || String(file).includes("_generated"))
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => void reload(), 100);
+    });
+    const stop = () => {
+        tenants.close();
+        server.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+}
+async function main() {
+    const flags = parse(process.argv.slice(2));
+    const command = flags._[0] ?? "help";
+    const p = paths(process.cwd());
+    switch (command) {
+        case "init": {
+            const created = scaffold(p);
+            console.log(created.length > 0 ? `Created ${created.join(", ")}` : "databob/ already exists. Nothing to create.");
+            console.log("Next: npx databob dev");
+            return;
+        }
+        case "dev":
+            return dev(p, flags);
+        case "start":
+            return start(p, flags);
+        case "deploy":
+            return deploy(p, flags);
+        case "codegen": {
+            const written = codegen(p);
+            console.log(written.length > 0 ? `Wrote ${written.join(", ")}` : "Generated files are up to date.");
+            return;
+        }
+        case "check": {
+            const loaded = await loadOrExit(p);
+            console.log(`✓ ${Object.keys(loaded.schema.events).length} event(s) and ${Object.keys(loaded.metrics).length} metric(s) are valid`);
+            return;
+        }
+        case "describe": {
+            const loaded = await loadOrExit(p);
+            print({ schema: loaded.schema, metrics: loaded.metrics });
+            return;
+        }
+        case "query": {
+            const name = flags._[1];
+            if (!name)
+                throw new Error("Usage: databob query <metric> [--args JSON] [--tenant id]");
+            const { engine, project, tenants } = await local(p);
+            const options = {};
+            const tenant = str(flags, "tenant");
+            if (tenant)
+                options.tenant = tenant;
+            const tz = str(flags, "tz");
+            if (tz)
+                options.timeZone = tz;
+            if (flags.compare)
+                options.compare = "previous";
+            print(await engine.metric(project, name, jsonFlag(flags, "args") ?? {}, options));
+            tenants.close();
+            return;
+        }
+        case "track": {
+            const name = flags._[1];
+            if (!name)
+                throw new Error("Usage: databob track <event> [--props JSON] [--tenant id] [--user id]");
+            const event = { name, props: jsonFlag(flags, "props") ?? {} };
+            const tenant = str(flags, "tenant");
+            if (tenant)
+                event.tenant = tenant;
+            const user = str(flags, "user");
+            if (user)
+                event.user = user;
+            // Prefer a running dev server, so live views see the event.
+            const state = devState(p);
+            const port = Number(str(flags, "port") ?? process.env.DATABOB_PORT ?? 4100);
+            try {
+                const response = await fetch(`http://127.0.0.1:${port}/v1/track`, {
+                    method: "POST",
+                    headers: { authorization: `Bearer ${state.secretKey}`, "content-type": "application/json" },
+                    body: JSON.stringify(event),
+                });
+                const result = (await response.json());
+                print(result);
+                if (!response.ok || (result.rejected?.length ?? 0) > 0)
+                    process.exit(1);
+                return;
+            }
+            catch {
+                // No dev server. Write to the local data directly.
+            }
+            const { engine, project, tenants } = await local(p);
+            const result = await engine.track(project, [event]);
+            print(result);
+            tenants.close();
+            if (result.rejected.length > 0)
+                process.exit(1);
+            return;
+        }
+        case "help":
+        case "--help":
+        case "-h":
+            console.log(HELP);
+            return;
+        default:
+            console.error(`Unknown command "${command}".\n`);
+            console.log(HELP);
+            process.exit(1);
+    }
+}
+main().catch((error) => {
+    if (error instanceof EngineError || error instanceof ProjectLoadError)
+        console.error(`✗ ${error.message}`);
+    else
+        console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { v, defineSchema, event, metricFactory, queryRoot, type AggregateResult, type AnySchema, type Cell, type EventNames, type EventProps, type FunnelResult, type FunnelStep, type Infer, type MetricDef, type QueryAst, type QueryResult, type RangeValue, type Schema, } from "@databob/engine";
+export { makeApi, ref, type ApiFromModule, type MetricRef, type RefArgs, type RefResult } from "./api.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+// databob: typed product analytics you define in code.
+//
+//   databob/schema.ts    events and their properties
+//   databob/metrics.ts   named queries your app and your users read
+//   databob/_generated   written by `databob dev`; commit it
+export { v, defineSchema, event, metricFactory, queryRoot, } from "@databob/engine";
+export { makeApi, ref } from "./api.js";

package/dist/project.d.ts

@@ -0,0 +1,31 @@
+import { type MetricJson, type ProjectConfig, type SchemaJson } from "@databob/engine";
+export declare const SOURCE_DIR = "databob";
+export declare const STATE_DIR = ".databob";
+export type Paths = {
+    root: string;
+    source: string;
+    generated: string;
+    state: string;
+    data: string;
+    build: string;
+};
+export declare function paths(root: string): Paths;
+export declare function codegen(p: Paths): string[];
+export declare function scaffold(p: Paths): string[];
+export type LoadedProject = {
+    schema: SchemaJson;
+    metrics: Record<string, MetricJson>;
+    problems: string[];
+};
+export declare class ProjectLoadError extends Error {
+}
+export declare function loadProject(p: Paths): Promise<LoadedProject>;
+export type DevState = {
+    projectId: string;
+    secretKey: string;
+    signingKey: string;
+    userKey: string;
+};
+export declare function devState(p: Paths): DevState;
+export declare function projectConfig(state: DevState, loaded: LoadedProject): ProjectConfig;
+export declare function writeEnv(p: Paths, url: string, secretKey: string): string[];

package/dist/project.js

@@ -0,0 +1,283 @@
+// Finds, scaffolds, generates, and loads a databob project directory.
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { isMetric, projectProblems, randomToken, schemaToJson, } from "@databob/engine";
+export const SOURCE_DIR = "databob";
+export const STATE_DIR = ".databob";
+export function paths(root) {
+    const state = join(root, STATE_DIR);
+    return {
+        root,
+        source: join(root, SOURCE_DIR),
+        generated: join(root, SOURCE_DIR, "_generated"),
+        state,
+        data: join(state, "data"),
+        build: join(state, "build"),
+    };
+}
+function findEntry(dir, base) {
+    for (const extension of [".ts", ".mts", ".js", ".mjs"]) {
+        const file = join(dir, base + extension);
+        if (existsSync(file))
+            return file;
+    }
+    return null;
+}
+const SCHEMA_TEMPLATE = `import { defineSchema, event, v } from "@databob/sdk";
+
+export default defineSchema({
+  // Every event belongs to one of your customers (a workspace, a store, an org).
+  // Each tenant is stored on its own and can be shown its own analytics.
+  tenants: true,
+  events: {
+    pageview: event({ path: v.string() }),
+    signup: event({ plan: v.enum(["free", "pro"]) }),
+    purchase: event({ amount: v.number({ min: 0 }), plan: v.enum(["free", "pro"]) }),
+  },
+});
+`;
+const METRICS_TEMPLATE = `import { v } from "@databob/sdk";
+import { metric } from "./_generated/server";
+
+export const pageviews = metric({
+  description: "Pageviews and users per day",
+  args: { range: v.optional(v.range()) },
+  query: (q, { range }) => q.events("pageview").range(range ?? "30d").by("$day").count("views").users(),
+});
+
+export const topPages = metric({
+  description: "Most viewed pages",
+  args: { range: v.optional(v.range()) },
+  query: (q, { range }) => q.events("pageview").range(range ?? "7d").by("path").count("views").limit(10),
+});
+
+export const revenue = metric({
+  description: "Revenue by plan",
+  args: { range: v.optional(v.range()) },
+  query: (q, { range }) => q.events("purchase").range(range ?? "30d").by("plan").sum("amount", "revenue").count("orders"),
+});
+
+export const activation = metric({
+  description: "Signed up, then purchased within 7 days",
+  query: (q) => q.funnel("signup", "purchase").within("7d").range("30d"),
+});
+`;
+const README_TEMPLATE = `# databob
+
+This folder defines your analytics. \`npx databob dev\` watches it.
+
+- \`schema.ts\` lists every event and its properties. An event that is not here is refused.
+- \`metrics.ts\` holds named queries. Your server and your users' browsers read them by name.
+- \`_generated/\` is written by databob. Commit it, do not edit it.
+
+Track on the server:
+
+\`\`\`ts
+import { Databob } from "@databob/sdk/server";
+import type { Schema } from "./databob/_generated/server";
+
+const databob = new Databob<Schema>();
+await databob.track("signup", { plan: "pro" }, { tenant: org.id, user: user.id });
+\`\`\`
+
+Show a tenant its own numbers:
+
+\`\`\`ts
+// server: mint a token for one tenant
+const { token } = await databob.createToken({ tenant: org.id });
+\`\`\`
+
+\`\`\`tsx
+// browser
+import { DatabobProvider, useMetric } from "@databob/sdk/react";
+import { api } from "./databob/_generated/api";
+
+const { data } = useMetric(api.topPages, { range: "7d" }, { live: true });
+\`\`\`
+
+Rules databob enforces:
+
+- No personal data. Property names like \`email\` or \`ip\` are refused, and values that look like an email, IP address, phone number, or card number are refused.
+- User ids are stored as a keyed hash. \`databob.deleteUser(id)\` erases that user everywhere.
+- Queries are JSON compiled to SQL with bound values. Your query code never runs on the server.
+
+Agents: run \`npx databob describe\` for the schema and metrics as JSON, \`npx databob check\` to validate,
+and \`npx databob query <metric> --args '{"range":"7d"}' --tenant <id>\` to read data.
+`;
+const SERVER_GENERATED = `/* Generated by databob. Do not edit. */
+import schema from "../schema";
+import { metricFactory, queryRoot } from "@databob/sdk";
+
+export type Schema = typeof schema;
+
+// Define metrics with this so event names, properties, and rows are typed.
+export const metric = metricFactory(schema);
+
+// Build an ad hoc query with the same types.
+export const q = queryRoot(schema);
+`;
+const API_GENERATED = `/* Generated by databob. Do not edit. */
+import { makeApi } from "@databob/sdk";
+import type * as metrics from "../metrics";
+
+// Typed references to your metrics. Safe to import in the browser: it holds
+// names only, not query definitions.
+export const api = makeApi<typeof metrics>();
+`;
+// Ignores line endings, so a CRLF checkout (git autocrlf on Windows) does not
+// get its generated files rewritten on every run.
+function writeIfChanged(file, content) {
+    if (existsSync(file) && readFileSync(file, "utf8").replace(/\r\n/g, "\n") === content)
+        return false;
+    writeFileSync(file, content);
+    return true;
+}
+export function codegen(p) {
+    mkdirSync(p.generated, { recursive: true });
+    const written = [];
+    if (writeIfChanged(join(p.generated, "server.ts"), SERVER_GENERATED))
+        written.push("server.ts");
+    if (writeIfChanged(join(p.generated, "api.ts"), API_GENERATED))
+        written.push("api.ts");
+    return written;
+}
+export function scaffold(p) {
+    mkdirSync(p.source, { recursive: true });
+    const created = [];
+    const files = [
+        ["schema.ts", SCHEMA_TEMPLATE],
+        ["metrics.ts", METRICS_TEMPLATE],
+        ["README.md", README_TEMPLATE],
+    ];
+    for (const [name, content] of files) {
+        const file = join(p.source, name);
+        if (name !== "README.md" && findEntry(p.source, name.replace(/\.ts$/, "")))
+            continue;
+        if (existsSync(file))
+            continue;
+        writeFileSync(file, content);
+        created.push(relative(p.root, file));
+    }
+    codegen(p);
+    ignoreState(p);
+    return created;
+}
+function ignoreState(p) {
+    const file = join(p.root, ".gitignore");
+    const line = `${STATE_DIR}/`;
+    if (existsSync(file)) {
+        const content = readFileSync(file, "utf8");
+        if (content.split(/\r?\n/).some((entry) => entry.trim() === line || entry.trim() === STATE_DIR))
+            return;
+        appendFileSync(file, `${content.endsWith("\n") || content === "" ? "" : "\n"}${line}\n`);
+    }
+    else {
+        writeFileSync(file, `${line}\n`);
+    }
+}
+export class ProjectLoadError extends Error {
+}
+export async function loadProject(p) {
+    const schemaFile = findEntry(p.source, "schema");
+    if (!schemaFile)
+        throw new ProjectLoadError(`No ${SOURCE_DIR}/schema.ts. Run \`npx databob init\`.`);
+    const metricsFile = findEntry(p.source, "metrics");
+    codegen(p);
+    const { build } = await import("esbuild");
+    const entryPoints = { schema: schemaFile };
+    if (metricsFile)
+        entryPoints.metrics = metricsFile;
+    mkdirSync(p.build, { recursive: true });
+    try {
+        await build({
+            entryPoints,
+            outdir: p.build,
+            outExtension: { ".js": ".mjs" },
+            bundle: true,
+            platform: "node",
+            format: "esm",
+            packages: "external",
+            logLevel: "silent",
+            write: true,
+        });
+    }
+    catch (error) {
+        const errors = error.errors ?? [];
+        const details = errors.map((item) => (item.location ? `${item.location.file}:${item.location.line} ${item.text}` : item.text));
+        throw new ProjectLoadError(details.length > 0 ? details.join("\n") : String(error));
+    }
+    const stamp = `?v=${Date.now()}`;
+    let schemaModule;
+    try {
+        schemaModule = (await import(pathToFileURL(join(p.build, "schema.mjs")).href + stamp));
+    }
+    catch (error) {
+        throw new ProjectLoadError(`${SOURCE_DIR}/schema.ts: ${error instanceof Error ? error.message : error}`);
+    }
+    const schema = schemaModule.default;
+    if (!schema || schema.kind !== "schema") {
+        throw new ProjectLoadError(`${SOURCE_DIR}/schema.ts must \`export default defineSchema({ ... })\``);
+    }
+    const metrics = {};
+    if (metricsFile) {
+        let metricsModule;
+        try {
+            metricsModule = (await import(pathToFileURL(join(p.build, "metrics.mjs")).href + stamp));
+        }
+        catch (error) {
+            throw new ProjectLoadError(`${SOURCE_DIR}/metrics.ts: ${error instanceof Error ? error.message : error}`);
+        }
+        for (const [name, value] of Object.entries(metricsModule)) {
+            if (!isMetric(value))
+                continue;
+            const entry = { args: value.args, query: value.query };
+            if (value.description !== undefined)
+                entry.description = value.description;
+            metrics[name] = JSON.parse(JSON.stringify(entry));
+        }
+    }
+    const json = schemaToJson(schema);
+    return { schema: json, metrics, problems: projectProblems(json, metrics) };
+}
+export function devState(p) {
+    const file = join(p.state, "dev.json");
+    if (existsSync(file))
+        return JSON.parse(readFileSync(file, "utf8"));
+    mkdirSync(p.state, { recursive: true });
+    const state = {
+        projectId: "local",
+        secretKey: `dbsk_dev_${randomToken(24)}`,
+        signingKey: randomToken(32),
+        userKey: randomToken(32),
+    };
+    writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`);
+    return state;
+}
+export function projectConfig(state, loaded) {
+    return {
+        id: state.projectId,
+        schema: loaded.schema,
+        metrics: loaded.metrics,
+        signingKey: state.signingKey,
+        userKey: state.userKey,
+    };
+}
+// Adds DATABOB_URL and DATABOB_SECRET_KEY to .env.local when they are missing.
+export function writeEnv(p, url, secretKey) {
+    const file = join(p.root, ".env.local");
+    const existing = existsSync(file) ? readFileSync(file, "utf8") : "";
+    const has = (name) => new RegExp(`^\\s*${name}\\s*=`, "m").test(existing);
+    const lines = [];
+    if (!has("DATABOB_URL"))
+        lines.push(`DATABOB_URL=${url}`);
+    if (!has("DATABOB_SECRET_KEY"))
+        lines.push(`DATABOB_SECRET_KEY=${secretKey}`);
+    if (!has("NEXT_PUBLIC_DATABOB_URL"))
+        lines.push(`NEXT_PUBLIC_DATABOB_URL=${url}`);
+    if (lines.length === 0)
+        return [];
+    const prefix = existing === "" || existing.endsWith("\n") ? "" : "\n";
+    appendFileSync(file, `${prefix}${lines.join("\n")}\n`);
+    return lines.map((line) => line.split("=")[0]);
+}