@dtdyq/restbase 1.0.0

package/crud.ts

@@ -0,0 +1,329 @@
+/**
+ * crud.ts — 通用 CRUD 路由 + Body 模式查询/删除
+ *
+ * ── 数据操作（/api/data，URL 参数模式，适合 CLI 调试） ──
+ * GET    /api/data/:table/:id  — 按主键查单条
+ * POST   /api/data/:table      — 创建（object 或 array），已存在则报错
+ * PUT    /api/data/:table      — 不存在创建、存在增量覆盖（upsert）
+ * DELETE /api/data/:table/:id  — 按主键删除单条
+ * DELETE /api/data/:table      — 按条件批量删除（WHERE 语法同 GET）
+ * GET    /api/data/:table      — 复杂条件列表查询（URL query 参数）
+ *
+ * ── 前端接口（POST JSON Body，适合前端调用） ──
+ * POST   /api/query/:table     — Body 传入 select/where/order/group/分页
+ * POST   /api/delete/:table    — Body 传入 where 条件
+ *
+ * 含 owner 字段的表自动按当前用户过滤
+ * auth 表不允许通过此接口操作（使用 /api/auth/* ）
+ */
+import type {Hono} from "hono";
+import {zValidator} from "@hono/zod-validator";
+import {
+    type AppEnv, AppError, cfg, ok, ownerCond, paged, q,
+    zodHook, bodyQuerySchema, bodyDeleteSchema, bodyDataSchema,
+    type BodyQuery, type BodyWhereInput,
+} from "./types.ts";
+import {getTable, isAuthTable, run, type TblMeta} from "./db.ts";
+import {buildBodyDeleteSQL, buildBodyListSQL, buildDeleteSQL, buildListSQL} from "./query.ts";
+
+/* ═══════════ 注册路由 ═══════════ */
+
+export function registerCrudRoutes(app: Hono<AppEnv>) {
+    /* ══════════════════════════════════════════════════════════
+       前端接口（POST JSON Body）
+       ══════════════════════════════════════════════════════════ */
+
+    /* ── POST /api/query/:table — Body 查询 ── */
+    app.post("/api/query/:table", zValidator("json", bodyQuerySchema, zodHook as any), async (c) => {
+        const tbl = requireTable(c.req.param("table"));
+        const userId = c.get("userId");
+        const body = c.req.valid("json") as BodyQuery;
+
+        const {
+            sql, countSql, values, countValues, pageNo, pageSize,
+        } = buildBodyListSQL(tbl, body, userId);
+
+        const rows = (await run(sql, values)) as any[];
+        const data = stripOwner(rows, tbl);
+
+        if (pageNo !== undefined && pageSize !== undefined) {
+            const [countRow] = (await run(countSql, countValues)) as any[];
+            return c.json(paged(data, pageNo, pageSize, Number(countRow?.total ?? 0)));
+        }
+        return c.json(ok(data));
+    });
+
+    /* ── POST /api/delete/:table — Body 条件删除 ── */
+    app.post("/api/delete/:table", zValidator("json", bodyDeleteSchema, zodHook as any), async (c) => {
+        const tbl = requireTable(c.req.param("table"));
+        const userId = c.get("userId");
+        const body = c.req.valid("json")
+
+        const {sql, values} = buildBodyDeleteSQL(tbl, body, userId);
+        const ids = await collectDeletedIds(tbl, sql, values);
+        await run(sql, values);
+        return c.json(ok({deleted: ids}));
+    });
+
+    /* ══════════════════════════════════════════════════════════
+       数据操作（URL 参数模式，适合 CLI 调试）
+       ══════════════════════════════════════════════════════════ */
+
+    /* ── GET /api/data/:table/:id — 查单条 ── */
+    app.get("/api/data/:table/:id", async (c) => {
+        const {table: tName, id} = c.req.param();
+        const tbl = requireTable(tName);
+        if (!tbl.pk)
+            throw new AppError("TABLE_ERROR", `Table "${tName}" has no primary key`);
+
+        const pkCol = tbl.colMap.get(tbl.pk)!;
+        const params: unknown[] = [pkCol.isNumeric ? Number(id) : id];
+        let sql = `SELECT *
+                   FROM ${q(tName)}
+                   WHERE ${q(tbl.pk)} = $1`;
+
+        if (tbl.hasOwner) {
+            sql += ` AND ${ownerCond(2)}`;
+            params.push(c.get("userId"));
+        }
+
+        const rows = await run(sql, params);
+        if (rows.length === 0) return c.json(ok(null));
+
+        const row = {...(rows[0] as any)};
+        if (tbl.hasOwner) delete row[cfg.ownerField];
+        return c.json(ok(row));
+    });
+
+    /* ── POST /api/data/:table — 创建（存在则报错） ── */
+    app.post("/api/data/:table", zValidator("json", bodyDataSchema, zodHook as any), async (c) => {
+        const tbl = requireTable(c.req.param("table"));
+        const body = c.req.valid("json");
+        const items: Record<string, unknown>[] = Array.isArray(body) ? body : [body];
+        const userId = c.get("userId");
+        const created: unknown[] = [];
+
+        for (const item of items) {
+            if (tbl.pk && item[tbl.pk] !== undefined) {
+                const exist = await run(
+                    `SELECT 1
+                     FROM ${q(tbl.name)}
+                     WHERE ${q(tbl.pk)} = $1`,
+                    [item[tbl.pk]],
+                );
+                if (exist.length > 0)
+                    throw new AppError(
+                        "CONFLICT",
+                        `Record ${tbl.pk}=${item[tbl.pk]} already exists`,
+                    );
+            }
+            created.push(await insertRow(tbl, item, userId));
+        }
+        return c.json(ok({created}));
+    });
+
+    /* ── PUT /api/data/:table — 不存在创建，存在增量覆盖 ── */
+    app.put("/api/data/:table", zValidator("json", bodyDataSchema, zodHook as any), async (c) => {
+        const tbl = requireTable(c.req.param("table"));
+        const body = c.req.valid("json");
+        const items: Record<string, unknown>[] = Array.isArray(body) ? body : [body];
+        const userId = c.get("userId");
+        const created: unknown[] = [];
+        const updated: unknown[] = [];
+
+        for (const item of items) {
+            if (tbl.pk && item[tbl.pk] !== undefined) {
+                if (await existsRow(tbl, item[tbl.pk], userId)) {
+                    await updateRow(tbl, item, userId);
+                    updated.push(item[tbl.pk]);
+                    continue;
+                }
+            }
+            created.push(await insertRow(tbl, item, userId));
+        }
+        return c.json(ok({created, updated}));
+    });
+
+    /* ── DELETE /api/data/:table/:id — 按主键删除单条 ── */
+    app.delete("/api/data/:table/:id", async (c) => {
+        const {table: tName, id} = c.req.param();
+        const tbl = requireTable(tName);
+        if (!tbl.pk)
+            throw new AppError("TABLE_ERROR", `Table "${tName}" has no primary key`);
+
+        const pkCol = tbl.colMap.get(tbl.pk)!;
+        const pkVal = pkCol.isNumeric ? Number(id) : id;
+        const params: unknown[] = [pkVal];
+        let sql = `DELETE
+                   FROM ${q(tName)}
+                   WHERE ${q(tbl.pk)} = $1`;
+        if (tbl.hasOwner) {
+            sql += ` AND ${ownerCond(2)}`;
+            params.push(c.get("userId"));
+        }
+        const result = await run(sql, params);
+        const deleted = (result as any).count > 0 ? [pkVal] : [];
+        return c.json(ok({deleted}));
+    });
+
+    /* ── DELETE /api/data/:table — 按条件批量删除（URL query） ── */
+    app.delete("/api/data/:table", async (c) => {
+        const tbl = requireTable(c.req.param("table"));
+        const userId = c.get("userId");
+
+        const params: Record<string, string> = {};
+        const url = new URL(c.req.url);
+        for (const [k, v] of url.searchParams.entries()) params[k] = v;
+
+        const {sql, values} = buildDeleteSQL(tbl, params, userId);
+        const ids = await collectDeletedIds(tbl, sql, values);
+        await run(sql, values);
+        return c.json(ok({deleted: ids}));
+    });
+
+    /* ── GET /api/data/:table — 复杂条件列表查询（URL query） ── */
+    app.get("/api/data/:table", async (c) => {
+        const tbl = requireTable(c.req.param("table"));
+        const userId = c.get("userId");
+
+        const params: Record<string, string> = {};
+        const url = new URL(c.req.url);
+        for (const [k, v] of url.searchParams.entries()) params[k] = v;
+
+        const {
+            sql, countSql, values, countValues, pageNo, pageSize,
+        } = buildListSQL(tbl, params, userId);
+
+        const rows = (await run(sql, values)) as any[];
+        const data = stripOwner(rows, tbl);
+
+        if (pageNo !== undefined && pageSize !== undefined) {
+            const [countRow] = (await run(countSql, countValues)) as any[];
+            return c.json(paged(data, pageNo, pageSize, Number(countRow?.total ?? 0)));
+        }
+        return c.json(ok(data));
+    });
+}
+
+/* ═══════════ 内部工具 ═══════════ */
+
+/**
+ * 在执行 DELETE 之前，先用相同 WHERE 条件 SELECT 出即将被删的主键列表。
+ * 将 DELETE SQL 改写为 SELECT pk FROM ... WHERE ...
+ */
+async function collectDeletedIds(
+    tbl: TblMeta, deleteSql: string, values: unknown[],
+): Promise<unknown[]> {
+    if (!tbl.pk) return [];
+    /* 把 "DELETE ... FROM ..." 替换为 "SELECT pk FROM ..."（SQL 模板可能含换行） */
+    const selectSql = deleteSql.replace(
+        /^DELETE\s+FROM/i,
+        `SELECT ${q(tbl.pk)} FROM`,
+    );
+    const rows = await run(selectSql, values);
+    return rows.map((r: any) => r[tbl.pk!]);
+}
+
+/** 去掉 owner 字段 */
+function stripOwner(rows: any[], tbl: TblMeta): any[] {
+    if (!tbl.hasOwner) return rows;
+    return rows.map((r) => {
+        const row = {...r};
+        delete row[cfg.ownerField];
+        return row;
+    });
+}
+
+/** 校验表名：禁止直接操作 auth 表、表必须存在 */
+function requireTable(name: string): TblMeta {
+    if (isAuthTable(name))
+        throw new AppError("FORBIDDEN", "Use /api/auth/* for auth table");
+    const tbl = getTable(name);
+    if (!tbl) throw new AppError("NOT_FOUND", `Table "${name}" not found`);
+    return tbl;
+}
+
+/** 判断行是否存在（带 owner 过滤） */
+async function existsRow(
+    tbl: TblMeta, pkVal: unknown, userId: number,
+): Promise<boolean> {
+    const params: unknown[] = [pkVal];
+    let sql = `SELECT 1
+               FROM ${q(tbl.name)}
+               WHERE ${q(tbl.pk!)} = $1`;
+    if (tbl.hasOwner) {
+        sql += ` AND ${ownerCond(2)}`;
+        params.push(userId);
+    }
+    return (await run(sql, params)).length > 0;
+}
+
+/** 插入一行，返回主键值 */
+async function insertRow(
+    tbl: TblMeta, item: Record<string, unknown>, userId: number,
+): Promise<unknown> {
+    const cols: string[] = [];
+    const vals: unknown[] = [];
+
+    for (const [k, v] of Object.entries(item)) {
+        /* 禁止用户自行指定 owner（防止伪造身份） */
+        if (k === cfg.ownerField && tbl.hasOwner) continue;
+        if (tbl.colMap.has(k)) {
+            cols.push(k);
+            vals.push(v);
+        }
+    }
+
+    /* 自动填充 owner（始终使用当前用户 ID） */
+    if (tbl.hasOwner) {
+        cols.push(cfg.ownerField);
+        vals.push(userId);
+    }
+
+    const ph = cols.map((_, i) => `$${i + 1}`).join(", ");
+    await run(
+        `INSERT INTO ${q(tbl.name)} (${cols.map(q).join(", ")})
+         VALUES (${ph})`,
+        vals,
+    );
+
+    /* 获取插入的主键 */
+    if (tbl.pk && item[tbl.pk] !== undefined) return item[tbl.pk];
+    if (tbl.pk) {
+        const [row] = cfg.isSqlite
+            ? await run(`SELECT last_insert_rowid() AS id`)
+            : await run(`SELECT LAST_INSERT_ID() AS id`);
+        return (row as any).id;
+    }
+    return null;
+}
+
+/** 增量更新一行（仅更新传入的字段） */
+async function updateRow(
+    tbl: TblMeta, item: Record<string, unknown>, userId: number,
+) {
+    const sets: string[] = [];
+    const vals: unknown[] = [];
+    let n = 1;
+
+    for (const [k, v] of Object.entries(item)) {
+        /* 跳过主键和 owner 字段（owner 不可被用户修改） */
+        if (k === tbl.pk) continue;
+        if (k === cfg.ownerField && tbl.hasOwner) continue;
+        if (tbl.colMap.has(k)) {
+            sets.push(`${q(k)} = $${n++}`);
+            vals.push(v);
+        }
+    }
+    if (sets.length === 0) return;
+
+    let sql = `UPDATE ${q(tbl.name)}
+               SET ${sets.join(", ")}
+               WHERE ${q(tbl.pk!)} = $${n++}`;
+    vals.push(item[tbl.pk!]);
+    if (tbl.hasOwner) {
+        sql += ` AND ${ownerCond(n++)}`;
+        vals.push(userId);
+    }
+    await run(sql, vals);
+}

package/db.ts

@@ -0,0 +1,197 @@
+/**
+ * db.ts — 数据库连接、表结构分析、初始化校验
+ *
+ * 启动时：
+ *   1. 确保 auth 表存在（不存在则创建最小结构）
+ *   2. 获取全部表的列名、类型、主键、是否有 owner 字段
+ *   3. 校验 auth 表必须包含 id / username / password
+ */
+import {cfg, q, reqStore} from "./types.ts";
+import {log} from "./logger.ts";
+
+/* ═══════════ 元数据类型 ═══════════ */
+
+export interface ColMeta {
+    name: string;
+    type: string;       // 原始类型（小写）
+    isNumeric: boolean;
+}
+
+export interface TblMeta {
+    name: string;
+    columns: ColMeta[];
+    colMap: Map<string, ColMeta>;  // name → ColMeta（快速查找）
+    pk: string | null;              // 主键字段名
+    hasOwner: boolean;              // 是否含 owner 字段
+}
+
+/* ═══════════ 全局表缓存 ═══════════ */
+
+const tables = new Map<string, TblMeta>();
+
+export const getTable = (name: string) => tables.get(name);
+export const allTables = () => tables;
+export const isAuthTable = (name: string) => name === cfg.authTable;
+
+/* ═══════════ 数据库实例 ═══════════ */
+
+export const db = new Bun.SQL(cfg.db);
+
+/** 执行 SQL（DEBUG 模式自动打印完整 SQL + 参数 + requestId） */
+export async function run(sql: string, values?: unknown[]): Promise<any[]> {
+    if (cfg.logLevel === "DEBUG") {
+        const requestId = reqStore.getStore()?.requestId;
+        log.debug({requestId, sql, params: values}, "SQL");
+    }
+    /* MySQL 的 unsafe() 不支持 $1/$2 占位符，需转换为 ?
+       跳过 SQL 字符串字面量内部的内容，避免误替换 */
+    const finalSql = cfg.isSqlite ? sql : sql.replace(
+        /'[^']*'|(\$\d+)/g,
+        (m, p1) => p1 ? "?" : m,
+    );
+    return (await db.unsafe(finalSql, values)) as any[];
+}
+
+/* ═══════════ 初始化入口 ═══════════ */
+
+export async function initDb() {
+    await ensureAuthTable();
+    /* 加载用户指定的初始化 SQL */
+    if (cfg.initSql) await loadInitSql();
+    const names = await listTables();
+    for (const n of names) tables.set(n, await introspect(n));
+    validateAuth();
+    log.info({tables: [...tables.keys()]}, `DB loaded ${tables.size} table(s)`);
+}
+
+/** 序列化单张表元数据 */
+function serializeMeta(meta: TblMeta) {
+    return {
+        name: meta.name,
+        pk: meta.pk,
+        hasOwner: meta.hasOwner,
+        columns: meta.columns.map((c) => ({
+            name: c.name, type: c.type, isNumeric: c.isNumeric,
+        })),
+    };
+}
+
+/** 获取所有非 auth 表的元数据（供 /api/meta/tables 使用） */
+export function getTablesMeta() {
+    const result: ReturnType<typeof serializeMeta>[] = [];
+    for (const [name, meta] of tables) {
+        if (name === cfg.authTable) continue;
+        result.push(serializeMeta(meta));
+    }
+    return result;
+}
+
+/** 获取指定表的元数据（供 /api/meta/tables/:name 使用） */
+export function getTableMetaByName(name: string) {
+    if (name === cfg.authTable) return null;
+    const meta = tables.get(name);
+    return meta ? serializeMeta(meta) : null;
+}
+
+/** 运行时重新同步数据库表结构（供 /api/meta/sync 使用） */
+export async function syncTablesMeta() {
+    tables.clear();
+    const names = await listTables();
+    for (const n of names) tables.set(n, await introspect(n));
+    validateAuth();
+    log.info({tables: [...tables.keys()]}, `Synced ${tables.size} table(s)`);
+    return getTablesMeta();
+}
+
+/** 读取并执行 DB_INIT_SQL 指定的 SQL 文件 */
+async function loadInitSql() {
+    const file = Bun.file(cfg.initSql);
+    if (!(await file.exists())) {
+        log.warn({path: cfg.initSql}, "DB_INIT_SQL file not found, skipping");
+        return;
+    }
+    const content = await file.text();
+    /* 移除单行注释后按分号分割 */
+    const cleaned = content.replace(/--.*$/gm, "");
+    const stmts = cleaned.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+    for (const stmt of stmts) {
+        await db.unsafe(stmt);
+    }
+    log.info({path: cfg.initSql, statements: stmts.length}, "Executed init SQL");
+}
+
+/* ═══════════ 确保 auth 表存在 ═══════════ */
+
+async function ensureAuthTable() {
+    const tbl = q(cfg.authTable);
+    if (cfg.isSqlite) {
+        await db.unsafe(`CREATE TABLE IF NOT EXISTS ${tbl} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      username TEXT NOT NULL UNIQUE,
+      password TEXT NOT NULL
+    )`);
+    } else {
+        await db.unsafe(`CREATE TABLE IF NOT EXISTS ${tbl} (
+      id INT AUTO_INCREMENT PRIMARY KEY,
+      username VARCHAR(255) NOT NULL UNIQUE,
+      password VARCHAR(255) NOT NULL
+    )`);
+    }
+}
+
+/* ═══════════ 获取所有表名 ═══════════ */
+
+async function listTables(): Promise<string[]> {
+    const rows = cfg.isSqlite
+        ? await db.unsafe(
+            `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`,
+        )
+        : await db.unsafe(
+            `SELECT TABLE_NAME AS name FROM information_schema.tables WHERE TABLE_SCHEMA = DATABASE()`,
+        );
+    return (rows as any[]).map((r) => r.name);
+}
+
+/* ═══════════ 分析单张表结构 ═══════════ */
+
+async function introspect(table: string): Promise<TblMeta> {
+    const columns: ColMeta[] = [];
+    let pk: string | null = null;
+
+    if (cfg.isSqlite) {
+        for (const r of (await db.unsafe(`PRAGMA table_info(${q(table)})`)) as any[]) {
+            const type = (r.type || "text").toLowerCase();
+            columns.push({name: r.name, type, isNumeric: NUM_RE.test(type)});
+            if (r.pk === 1) pk = r.name;
+        }
+    } else {
+        const rows = await db.unsafe(
+            `SELECT COLUMN_NAME, DATA_TYPE, COLUMN_KEY
+       FROM information_schema.columns
+       WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '${table}'
+       ORDER BY ORDINAL_POSITION`,
+        );
+        for (const r of rows as any[]) {
+            const type = (r.DATA_TYPE || "varchar").toLowerCase();
+            columns.push({name: r.COLUMN_NAME, type, isNumeric: NUM_RE.test(type)});
+            if (r.COLUMN_KEY === "PRI") pk = r.COLUMN_NAME;
+        }
+    }
+
+    const colMap = new Map(columns.map((c) => [c.name, c]));
+    return {name: table, columns, colMap, pk, hasOwner: colMap.has(cfg.ownerField)};
+}
+
+/** 数值型类型正则 */
+const NUM_RE = /int|real|float|double|decimal|numeric/;
+
+/* ═══════════ 校验 auth 表 ═══════════ */
+
+function validateAuth() {
+    const m = tables.get(cfg.authTable);
+    if (!m) throw new Error(`Auth table "${cfg.authTable}" not found`);
+    for (const f of ["id", "username", "password"]) {
+        if (!m.colMap.has(f))
+            throw new Error(`Auth table "${cfg.authTable}" missing required column: "${f}"`);
+    }
+}

package/logger.ts

@@ -0,0 +1,94 @@
+/**
+ * logger.ts — 基于 pino 的统一日志
+ *
+ * 支持：
+ *   - 控制台输出（LOG_CONSOLE，默认 true，纯文本格式）
+ *   - 文件输出（LOG_FILE，NDJSON 格式，pino-roll 按天+按大小滚动）
+ *   - 日志保留天数（LOG_RETAIN_DAYS，默认 7）
+ *   - 日志等级（LOG_LEVEL）
+ *
+ * 导出 log 实例，全局使用 log.info / log.debug / log.error / log.fatal
+ */
+import pino from "pino";
+import {cfg} from "./types.ts";
+
+/* ═══════════ pino level 映射 ═══════════ */
+
+const LEVEL_MAP: Record<string, string> = {
+    ERROR: "error",
+    INFO: "info",
+    DEBUG: "debug",
+};
+const pinoLevel = LEVEL_MAP[cfg.logLevel] ?? "info";
+
+/* ═══════════ 控制台纯文本流 ═══════════ */
+
+function createTextStream(): pino.DestinationStream {
+    return {
+        write(chunk: string) {
+            try {
+                const obj = JSON.parse(chunk);
+                const ts = obj.time || new Date().toISOString();
+                const level = (obj.level || "INFO").padEnd(5);
+                const msg = obj.msg || "";
+                const {level: _, time: _t, pid: _p, hostname: _h, msg: _m, ...rest} = obj;
+                const extra = Object.keys(rest).length > 0
+                    ? " " + Object.entries(rest).map(([k, v]) =>
+                    `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`
+                ).join(" ")
+                    : "";
+                process.stdout.write(`${ts} ${level} ${msg}${extra}\n`);
+            } catch {
+                process.stdout.write(chunk);
+            }
+        },
+    } as pino.DestinationStream;
+}
+
+/* ═══════════ 构建 multistream ═══════════ */
+
+const streams: pino.StreamEntry[] = [];
+
+/* 控制台（纯文本） */
+if (cfg.logConsole) {
+    streams.push({
+        level: pinoLevel as pino.Level,
+        stream: createTextStream(),
+    });
+}
+
+/* 文件（pino-roll 滚动写入 NDJSON） */
+if (cfg.logFile) {
+    const {default: buildRollStream} = await import("pino-roll");
+    const rollStream = await buildRollStream({
+        file: cfg.logFile,
+        frequency: "daily",
+        size: "20m",
+        dateFormat: "yyyy-MM-dd",
+        limit: {count: cfg.logRetainDays},
+        mkdir: true,
+    });
+
+    streams.push({
+        level: pinoLevel as pino.Level,
+        stream: rollStream,
+    });
+}
+
+/* ═══════════ 创建 logger ═══════════ */
+
+export const log: pino.Logger =
+    streams.length > 0
+        ? pino(
+            {
+                level: pinoLevel,
+                formatters: {
+                    level(label) {
+                        return {level: label.toUpperCase()};
+                    },
+                },
+                timestamp: () => `,"time":"${new Date().toISOString()}"`,
+            },
+            pino.multistream(streams),
+        )
+        : pino({level: pinoLevel, enabled: false});

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "@dtdyq/restbase",
+    "version": "1.0.0",
+    "description": "Zero-code REST API server for SQLite / MySQL with built-in auth, tenant isolation, and TypeScript client",
+    "keywords": ["rest", "api", "crud", "sqlite", "mysql", "hono", "bun", "zero-code"],
+    "license": "MIT",
+    "bin": {
+        "restbase": "./bin/restbase.ts"
+    },
+    "files": [
+        "bin/",
+        "server.ts",
+        "types.ts",
+        "db.ts",
+        "auth.ts",
+        "crud.ts",
+        "meta.ts",
+        "query.ts",
+        "logger.ts",
+        "client/",
+        "README.md"
+    ],
+    "engines": {
+        "bun": ">=1.2.0"
+    },
+    "scripts": {
+        "dev": "bun run --watch server.ts",
+        "start": "bun run server.ts",
+        "test": "bun test rest.test.ts",
+        "build": "bun build --compile --minify --sourcemap ./server.ts --outfile restbase",
+        "build:linux": "bun build --compile --minify --target=bun-linux-x64 ./server.ts --outfile restbase-linux-x64",
+        "build:linux-arm": "bun build --compile --minify --target=bun-linux-arm64 ./server.ts --outfile restbase-linux-arm64",
+        "build:mac": "bun build --compile --minify --target=bun-darwin-x64 ./server.ts --outfile restbase-darwin-x64",
+        "build:mac-arm": "bun build --compile --minify --target=bun-darwin-arm64 ./server.ts --outfile restbase-darwin-arm64",
+        "build:windows": "bun build --compile --minify --target=bun-windows-x64 ./server.ts --outfile restbase-windows-x64.exe"
+    },
+    "dependencies": {
+        "@hono/zod-validator": "^0.4.0",
+        "hono": "^4.6.0",
+        "pino": "^10.3.1",
+        "pino-roll": "^4.0.0",
+        "zod": "^3.23.0"
+    },
+    "devDependencies": {
+        "@types/bun": "latest"
+    },
+    "peerDependencies": {
+        "typescript": "^5"
+    }
+}