@dontcode2/backend 0.1.1 → 0.2.0

package/dist/mock/index.cjs

@@ -0,0 +1,886 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mock/index.ts
+var mock_exports = {};
+__export(mock_exports, {
+  startMockServer: () => startMockServer
+});
+module.exports = __toCommonJS(mock_exports);
+
+// src/mock/db-query.ts
+var QueryValidationError = class extends Error {
+};
+function ident(name) {
+  if (typeof name !== "string" || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new QueryValidationError(`Invalid identifier: ${JSON.stringify(name)}`);
+  }
+  return `"${name}"`;
+}
+function buildWhereClause(where, startParamIndex = 1) {
+  const conditions = [];
+  const values = [];
+  let paramIndex = startParamIndex;
+  for (const [key, value] of Object.entries(where)) {
+    if (key === "AND" && Array.isArray(value)) {
+      const subClauses = value.map((subWhere) => {
+        const result = buildWhereClause(subWhere, paramIndex);
+        paramIndex += result.values.length;
+        values.push(...result.values);
+        return result.clause.replace("WHERE ", "");
+      });
+      if (subClauses.length > 0) conditions.push(`(${subClauses.join(" AND ")})`);
+      continue;
+    }
+    if (key === "OR" && Array.isArray(value)) {
+      const subClauses = value.map((subWhere) => {
+        const result = buildWhereClause(subWhere, paramIndex);
+        paramIndex += result.values.length;
+        values.push(...result.values);
+        return result.clause.replace("WHERE ", "");
+      });
+      if (subClauses.length > 0) conditions.push(`(${subClauses.join(" OR ")})`);
+      continue;
+    }
+    if (key === "NOT" && value && typeof value === "object") {
+      const result = buildWhereClause(value, paramIndex);
+      paramIndex += result.values.length;
+      values.push(...result.values);
+      const notClause = result.clause.replace("WHERE ", "");
+      if (notClause) conditions.push(`NOT (${notClause})`);
+      continue;
+    }
+    const column = ident(key);
+    if (value === null) {
+      conditions.push(`${column} IS NULL`);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        conditions.push("FALSE");
+      } else {
+        const placeholders = value.map(() => `$${paramIndex++}`).join(", ");
+        conditions.push(`${column} IN (${placeholders})`);
+        values.push(...value);
+      }
+      continue;
+    }
+    if (value && typeof value === "object" && !(value instanceof Date)) {
+      const operators = value;
+      const like = operators.mode === "insensitive" ? "ILIKE" : "LIKE";
+      for (const [operator, operatorValue] of Object.entries(operators)) {
+        if (operator === "mode") continue;
+        switch (operator) {
+          case "equals":
+          case "eq":
+            if (operatorValue === null) {
+              conditions.push(`${column} IS NULL`);
+            } else {
+              conditions.push(`${column} = $${paramIndex++}`);
+              values.push(operatorValue);
+            }
+            break;
+          case "not":
+            if (operatorValue === null) {
+              conditions.push(`${column} IS NOT NULL`);
+            } else if (Array.isArray(operatorValue)) {
+              if (operatorValue.length === 0) {
+                conditions.push("TRUE");
+              } else {
+                const placeholders = operatorValue.map(() => `$${paramIndex++}`).join(", ");
+                conditions.push(`${column} NOT IN (${placeholders})`);
+                values.push(...operatorValue);
+              }
+            } else {
+              conditions.push(`${column} != $${paramIndex++}`);
+              values.push(operatorValue);
+            }
+            break;
+          case "gt":
+            conditions.push(`${column} > $${paramIndex++}`);
+            values.push(operatorValue);
+            break;
+          case "gte":
+            conditions.push(`${column} >= $${paramIndex++}`);
+            values.push(operatorValue);
+            break;
+          case "lt":
+            conditions.push(`${column} < $${paramIndex++}`);
+            values.push(operatorValue);
+            break;
+          case "lte":
+            conditions.push(`${column} <= $${paramIndex++}`);
+            values.push(operatorValue);
+            break;
+          case "in":
+            if (!Array.isArray(operatorValue) || operatorValue.length === 0) {
+              conditions.push("FALSE");
+            } else {
+              const placeholders = operatorValue.map(() => `$${paramIndex++}`).join(", ");
+              conditions.push(`${column} IN (${placeholders})`);
+              values.push(...operatorValue);
+            }
+            break;
+          case "notIn":
+            if (!Array.isArray(operatorValue) || operatorValue.length === 0) {
+              conditions.push("TRUE");
+            } else {
+              const placeholders = operatorValue.map(() => `$${paramIndex++}`).join(", ");
+              conditions.push(`${column} NOT IN (${placeholders})`);
+              values.push(...operatorValue);
+            }
+            break;
+          case "contains":
+            conditions.push(`${column} ${like} $${paramIndex++}`);
+            values.push(`%${operatorValue}%`);
+            break;
+          case "startsWith":
+            conditions.push(`${column} ${like} $${paramIndex++}`);
+            values.push(`${operatorValue}%`);
+            break;
+          case "endsWith":
+            conditions.push(`${column} ${like} $${paramIndex++}`);
+            values.push(`%${operatorValue}`);
+            break;
+          default:
+            throw new QueryValidationError(`Unsupported operator: ${operator}`);
+        }
+      }
+      continue;
+    }
+    conditions.push(`${column} = $${paramIndex++}`);
+    values.push(value);
+  }
+  return {
+    clause: conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "",
+    values
+  };
+}
+function buildOrderByClause(orderBy) {
+  if (!orderBy) return "";
+  const orders = Object.entries(orderBy).map(([col, dir]) => {
+    if (dir !== "asc" && dir !== "desc") {
+      throw new QueryValidationError(`Invalid sort direction: ${JSON.stringify(dir)}`);
+    }
+    return `${ident(col)} ${dir.toUpperCase()}`;
+  });
+  return `ORDER BY ${orders.join(", ")}`;
+}
+function buildSelectColumns(select) {
+  if (!select || select.length === 0) return "*";
+  return select.map(ident).join(", ");
+}
+function clampInt(value, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return null;
+  return Math.min(Math.floor(n), max);
+}
+var MAX_LIMIT = 1e3;
+function errorResult(err) {
+  if (err instanceof QueryValidationError) {
+    return { status: 400, body: { error: err.message } };
+  }
+  const pgErr = err;
+  const message = pgErr.message ?? "Database error";
+  if (pgErr.code === "23505" || pgErr.code === "23503") {
+    return { status: 409, body: { error: message } };
+  }
+  if (pgErr.code === "42P01" || pgErr.code === "42703") {
+    return { status: 400, body: { error: message } };
+  }
+  return { status: 500, body: { error: message } };
+}
+function rowCount(result) {
+  return result.affectedRows ?? result.rows.length;
+}
+async function executeDbOperation(db, schema, operation, tableName, options) {
+  try {
+    const table = `${ident(schema)}.${ident(tableName)}`;
+    if (options.include && (!Array.isArray(options.include) || options.include.length > 0) && Object.keys(options.include).length > 0) {
+      return {
+        status: 400,
+        body: { error: "include is not yet supported on the public API" }
+      };
+    }
+    switch (operation) {
+      case "find":
+      case "findMany": {
+        const { where, select, orderBy, limit, offset } = options;
+        const whereClause = where ? buildWhereClause(where) : { clause: "", values: [] };
+        const limitValue = limit !== void 0 ? clampInt(limit, MAX_LIMIT) : MAX_LIMIT;
+        const offsetValue = offset !== void 0 ? clampInt(offset, 1e9) : null;
+        const query = [
+          `SELECT ${buildSelectColumns(select)} FROM ${table}`,
+          whereClause.clause,
+          buildOrderByClause(orderBy),
+          limitValue !== null ? `LIMIT ${limitValue}` : "",
+          offsetValue !== null && offsetValue > 0 ? `OFFSET ${offsetValue}` : ""
+        ].filter(Boolean).join(" ");
+        const result = await db.query(query, whereClause.values);
+        return { status: 200, body: { data: result.rows } };
+      }
+      case "findFirst":
+      case "findOne": {
+        const { where, select, orderBy } = options;
+        const whereClause = where ? buildWhereClause(where) : { clause: "", values: [] };
+        const query = [
+          `SELECT ${buildSelectColumns(select)} FROM ${table}`,
+          whereClause.clause,
+          buildOrderByClause(orderBy),
+          "LIMIT 1"
+        ].filter(Boolean).join(" ");
+        const result = await db.query(query, whereClause.values);
+        return { status: 200, body: { data: result.rows[0] ?? null } };
+      }
+      case "insert": {
+        const { data } = options;
+        if (!data || typeof data !== "object" || Object.keys(data).length === 0) {
+          return { status: 400, body: { error: "Insert requires a data object" } };
+        }
+        const columns = Object.keys(data).map(ident);
+        const values = Object.values(data);
+        const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+        const query = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders}) RETURNING *`;
+        const result = await db.query(query, values);
+        const row = result.rows[0];
+        return { status: 200, body: { data: { id: row?.id ?? row } } };
+      }
+      case "update": {
+        const { where, data } = options;
+        if (!data || typeof data !== "object" || Object.keys(data).length === 0) {
+          return { status: 400, body: { error: "Update requires a data object" } };
+        }
+        if (!where || Object.keys(where).length === 0) {
+          return {
+            status: 400,
+            body: {
+              error: "Update requires a WHERE clause to prevent accidental updates of all records"
+            }
+          };
+        }
+        const setClauses = [];
+        const values = [];
+        let paramIndex = 1;
+        for (const [key, value] of Object.entries(data)) {
+          setClauses.push(`${ident(key)} = $${paramIndex++}`);
+          values.push(value);
+        }
+        const whereClause = buildWhereClause(where, paramIndex);
+        values.push(...whereClause.values);
+        const query = `UPDATE ${table} SET ${setClauses.join(", ")} ${whereClause.clause} RETURNING *`;
+        const result = await db.query(query, values);
+        return { status: 200, body: { data: { count: rowCount(result) } } };
+      }
+      case "delete": {
+        const { where } = options;
+        const whereClause = where ? buildWhereClause(where) : { clause: "", values: [] };
+        if (!whereClause.clause) {
+          return {
+            status: 400,
+            body: {
+              error: "Delete requires a WHERE clause to prevent accidental deletion of all records"
+            }
+          };
+        }
+        const query = `DELETE FROM ${table} ${whereClause.clause} RETURNING *`;
+        const result = await db.query(query, whereClause.values);
+        return { status: 200, body: { data: { count: rowCount(result) } } };
+      }
+      case "count": {
+        const { where } = options;
+        const whereClause = where ? buildWhereClause(where) : { clause: "", values: [] };
+        const query = [`SELECT COUNT(*) as count FROM ${table}`, whereClause.clause].filter(Boolean).join(" ");
+        const result = await db.query(query, whereClause.values);
+        return { status: 200, body: { data: parseInt(String(result.rows[0].count), 10) } };
+      }
+      default:
+        return { status: 400, body: { error: "Invalid operation" } };
+    }
+  } catch (err) {
+    return errorResult(err);
+  }
+}
+
+// src/mock/server.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_http = require("http");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var ACCESS_TOKEN_TTL_SECONDS = 60 * 60 * 24 * 7;
+function b64url(value) {
+  const str = typeof value === "string" ? value : JSON.stringify(value);
+  return Buffer.from(str).toString("base64url");
+}
+function mintToken(user) {
+  const now = Math.floor(Date.now() / 1e3);
+  const header = { alg: "none", typ: "JWT" };
+  const payload = {
+    sub: user.id,
+    email: user.email,
+    role: user.role,
+    claims: user.claims,
+    iat: now,
+    exp: now + ACCESS_TOKEN_TTL_SECONDS
+  };
+  return {
+    AccessToken: `${b64url(header)}.${b64url(payload)}.${b64url("dontcode-mock")}`,
+    ExpiresIn: ACCESS_TOKEN_TTL_SECONDS
+  };
+}
+function decodeToken(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    return typeof payload?.sub === "string" ? payload : null;
+  } catch {
+    return null;
+  }
+}
+function fileName(path) {
+  return path.split("/").filter(Boolean).pop() ?? path;
+}
+function normalizePath(value, { allowEmpty = false } = {}) {
+  if (typeof value !== "string") return allowEmpty && value === void 0 ? "" : null;
+  const path = value.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!allowEmpty && path.length === 0) return null;
+  if (path.split("/").some((segment) => segment === ".." || segment === ".")) return null;
+  if (/[\x00-\x1f]/.test(path)) return null;
+  return path;
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+async function startMockServer(options = {}) {
+  const port = options.port ?? 4e3;
+  const host = options.host ?? "127.0.0.1";
+  const schema = options.schema ?? "public";
+  const quiet = options.quiet ?? false;
+  const ephemeral = options.dataDir === null;
+  const dataDir = ephemeral ? (0, import_node_fs.mkdtempSync)((0, import_node_path.join)((0, import_node_os.tmpdir)(), "dontcode-mock-")) : options.dataDir ?? ".dontcode-mock";
+  if (!ephemeral) (0, import_node_fs.mkdirSync)(dataDir, { recursive: true });
+  const pglite = await loadPGlite();
+  const pgDir = ephemeral ? void 0 : (0, import_node_path.join)(dataDir, "pgdata");
+  const pg = pgDir ? new pglite.PGlite(pgDir) : new pglite.PGlite();
+  await pg.query("SELECT 1");
+  const db = {
+    query: async (sql, params) => {
+      const r = await pg.query(sql, params);
+      return { rows: r.rows, affectedRows: r.affectedRows };
+    }
+  };
+  const authFile = (0, import_node_path.join)(dataDir, "auth.json");
+  const users = /* @__PURE__ */ new Map();
+  if (!ephemeral && (0, import_node_fs.existsSync)(authFile)) {
+    try {
+      const saved = JSON.parse((0, import_node_fs.readFileSync)(authFile, "utf8"));
+      for (const u of saved) users.set(u.email.toLowerCase(), u);
+    } catch {
+    }
+  }
+  const persistUsers = () => {
+    if (ephemeral) return;
+    (0, import_node_fs.writeFileSync)(authFile, JSON.stringify([...users.values()], null, 2));
+  };
+  const storageDir = (0, import_node_path.join)(dataDir, "storage");
+  (0, import_node_fs.mkdirSync)(storageDir, { recursive: true });
+  const manifestFile = (0, import_node_path.join)(storageDir, "manifest.json");
+  const manifest = /* @__PURE__ */ new Map();
+  if ((0, import_node_fs.existsSync)(manifestFile)) {
+    try {
+      for (const [k, v] of Object.entries(
+        JSON.parse((0, import_node_fs.readFileSync)(manifestFile, "utf8"))
+      ))
+        manifest.set(k, v);
+    } catch {
+    }
+  }
+  const persistManifest = () => (0, import_node_fs.writeFileSync)(manifestFile, JSON.stringify(Object.fromEntries(manifest), null, 2));
+  const objKey = (bucket, path) => `${bucket}/${path}`;
+  const objFile = (bucket, path) => (0, import_node_path.join)(storageDir, bucket, path);
+  let baseUrl = `http://localhost:${port}`;
+  function objectShape(bucket, path) {
+    const meta = manifest.get(objKey(bucket, path));
+    return {
+      key: path,
+      name: fileName(path),
+      size: meta?.size ?? 0,
+      contentType: meta?.contentType ?? "application/octet-stream",
+      lastModified: meta?.lastModified ?? (/* @__PURE__ */ new Date()).toISOString(),
+      isFolder: false
+    };
+  }
+  function writeObject(bucket, path, body, contentType) {
+    const file = objFile(bucket, path);
+    (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(file), { recursive: true });
+    (0, import_node_fs.writeFileSync)(file, body);
+    manifest.set(objKey(bucket, path), {
+      contentType,
+      size: body.length,
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    persistManifest();
+  }
+  const server = (0, import_node_http.createServer)((req, res) => {
+    handle(req, res).catch((err) => {
+      if (!quiet) console.error("[dontcode-mock] handler error:", err);
+      sendJson(res, 500, { error: err instanceof Error ? err.message : "Internal error" });
+    });
+  });
+  function sendJson(res, status, body) {
+    const json = JSON.stringify(body);
+    res.writeHead(status, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.end(json);
+  }
+  function checkApiKey(req) {
+    const header = req.headers["authorization"];
+    if (typeof header !== "string" || !header.startsWith("Bearer ")) return false;
+    const key = header.slice(7).trim();
+    if (options.apiKey) return key === options.apiKey;
+    return key.startsWith("dc_");
+  }
+  async function handle(req, res) {
+    const url = new URL(req.url ?? "/", baseUrl);
+    const path = url.pathname;
+    const method = req.method ?? "GET";
+    if (method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET,POST,PUT,OPTIONS",
+        "Access-Control-Allow-Headers": "Authorization,Content-Type,X-Access-Token"
+      });
+      res.end();
+      return;
+    }
+    if (!quiet) console.log(`[dontcode-mock] ${method} ${path}`);
+    if (path === "/" && method === "GET") {
+      sendJson(res, 200, { service: "dontcode-mock", ok: true });
+      return;
+    }
+    if (path.startsWith("/__storage/")) {
+      await handleFileEndpoint(req, res, url, method);
+      return;
+    }
+    if (!path.startsWith("/api/v1/")) {
+      sendJson(res, 404, { error: "Not found" });
+      return;
+    }
+    if (!checkApiKey(req)) {
+      sendJson(res, 401, {
+        error: "Missing API key. Send it as: Authorization: Bearer <key>"
+      });
+      return;
+    }
+    const raw = await readBody(req);
+    if (path === "/api/v1/db" && method === "POST") {
+      const body = parseJson(raw);
+      const {
+        operation,
+        tableName,
+        options: opts
+      } = body;
+      if (!operation || !tableName) {
+        sendJson(res, 400, { error: "Operation and tableName are required" });
+        return;
+      }
+      const result = await executeDbOperation(db, schema, operation, tableName, opts ?? {});
+      sendJson(res, result.status, result.body);
+      return;
+    }
+    if (path === "/api/v1/db/migrate" && method === "POST") {
+      const { sql } = parseJson(raw);
+      if (!sql || typeof sql !== "string") {
+        sendJson(res, 400, { error: "sql is required" });
+        return;
+      }
+      try {
+        const results = await pg.exec(sql);
+        sendJson(res, 200, {
+          success: true,
+          executedStatements: Array.isArray(results) ? results.length : 1,
+          warnings: []
+        });
+      } catch (err) {
+        sendJson(res, 400, {
+          success: false,
+          error: err instanceof Error ? err.message : "Migration failed"
+        });
+      }
+      return;
+    }
+    if (path.startsWith("/api/v1/auth/") && method === "POST") {
+      await handleAuth(req, res, path.slice("/api/v1/auth/".length), raw);
+      return;
+    }
+    if (path === "/api/v1/storage") {
+      if (method === "POST") {
+        await handleStorageJson(res, parseJson(raw));
+        return;
+      }
+      if (method === "PUT") {
+        await handleStorageUpload(req, res, raw);
+        return;
+      }
+    }
+    sendJson(res, 404, { error: "Unknown endpoint" });
+  }
+  async function handleAuth(req, res, endpoint, raw) {
+    const body = parseJson(raw);
+    const accessToken = typeof req.headers["x-access-token"] === "string" ? req.headers["x-access-token"] : void 0;
+    switch (endpoint) {
+      case "signup": {
+        const email = String(body.email ?? "").trim();
+        const password = String(body.password ?? "");
+        if (!email || !password) {
+          sendJson(res, 400, { error: "Email and password are required" });
+          return;
+        }
+        if (users.has(email.toLowerCase())) {
+          sendJson(res, 409, { error: "Email already registered", code: "EmailExists" });
+          return;
+        }
+        const user = {
+          id: (0, import_node_crypto.randomUUID)(),
+          email,
+          password,
+          role: typeof body.role === "string" ? body.role : void 0,
+          verified: true
+        };
+        users.set(email.toLowerCase(), user);
+        persistUsers();
+        sendJson(res, 200, { success: true, userId: user.id, verified: true });
+        return;
+      }
+      case "login": {
+        const email = String(body.email ?? "").trim();
+        const password = String(body.password ?? "");
+        const user = users.get(email.toLowerCase());
+        if (!user || user.password !== password) {
+          sendJson(res, 401, { error: "Invalid email or password" });
+          return;
+        }
+        sendJson(res, 200, { success: true, userId: user.id, tokens: mintToken(user) });
+        return;
+      }
+      case "me": {
+        const decoded = accessToken ? decodeToken(accessToken) : null;
+        if (!decoded || decoded.exp && Date.now() / 1e3 >= decoded.exp) {
+          sendJson(res, 200, { user: null });
+          return;
+        }
+        const user = [...users.values()].find((u) => u.id === decoded.sub);
+        if (!user) {
+          sendJson(res, 200, { user: null });
+          return;
+        }
+        sendJson(res, 200, {
+          user: { id: user.id, email: user.email, role: user.role, claims: user.claims }
+        });
+        return;
+      }
+      case "verify-email":
+      case "forgot-password":
+      case "reset-password":
+        sendJson(res, 200, { success: true });
+        return;
+      case "mfa/enroll":
+        sendJson(res, 200, {
+          success: true,
+          secret: "MOCKMFASECRET",
+          otpauth_url: "otpauth://totp/DontCodeMock?secret=MOCKMFASECRET"
+        });
+        return;
+      case "mfa/enroll/confirm":
+        sendJson(res, 200, { success: true, recovery_codes: ["mock-recovery-0001"] });
+        return;
+      case "mfa/disable":
+        sendJson(res, 200, { success: true });
+        return;
+      case "mfa/challenge":
+        sendJson(res, 400, {
+          error: "MFA is not enabled in the mock",
+          code: "MfaNotOffered"
+        });
+        return;
+      default:
+        sendJson(res, 404, { error: "Unknown auth endpoint" });
+    }
+  }
+  async function handleStorageJson(res, body) {
+    const operation = body.operation;
+    const bucket = body.bucket === "public" || body.bucket === "private" ? body.bucket : null;
+    if (!bucket) {
+      sendJson(res, 400, { error: 'bucket must be "public" or "private"' });
+      return;
+    }
+    const bad = (msg) => sendJson(res, 400, { error: msg });
+    switch (operation) {
+      case "list": {
+        const prefix = normalizePath(body.prefix, { allowEmpty: true });
+        if (prefix === null) return bad("Invalid prefix");
+        const objects = [];
+        for (const key of manifest.keys()) {
+          if (!key.startsWith(`${bucket}/`)) continue;
+          const path = key.slice(bucket.length + 1);
+          if (prefix && !path.startsWith(`${prefix}/`) && path !== prefix) continue;
+          objects.push(objectShape(bucket, path));
+        }
+        sendJson(res, 200, {
+          objects,
+          folders: [],
+          prefix: prefix ? `${prefix}/` : "",
+          truncated: false,
+          continuationToken: null
+        });
+        return;
+      }
+      case "remove": {
+        const paths = Array.isArray(body.paths) ? body.paths.map((p) => normalizePath(p)) : null;
+        if (!paths || paths.length === 0 || paths.some((p) => p === null)) {
+          return bad("paths must be a non-empty array of valid paths");
+        }
+        for (const p of paths) {
+          const file = objFile(bucket, p);
+          if ((0, import_node_fs.existsSync)(file)) (0, import_node_fs.rmSync)(file);
+          manifest.delete(objKey(bucket, p));
+        }
+        persistManifest();
+        sendJson(res, 200, { deleted: paths.length });
+        return;
+      }
+      case "move": {
+        const from = normalizePath(body.from);
+        const to = normalizePath(body.to);
+        if (!from || !to) return bad("from and to are required");
+        const fromFile = objFile(bucket, from);
+        if (!(0, import_node_fs.existsSync)(fromFile)) return sendJson(res, 404, { error: "File not found" });
+        const buf = (0, import_node_fs.readFileSync)(fromFile);
+        const meta = manifest.get(objKey(bucket, from));
+        writeObject(bucket, to, buf, meta?.contentType ?? "application/octet-stream");
+        (0, import_node_fs.rmSync)(fromFile);
+        manifest.delete(objKey(bucket, from));
+        persistManifest();
+        sendJson(res, 200, { object: objectShape(bucket, to) });
+        return;
+      }
+      case "createFolder": {
+        const path = normalizePath(body.path);
+        if (!path) return bad("path is required");
+        (0, import_node_fs.mkdirSync)((0, import_node_path.join)(storageDir, bucket, path), { recursive: true });
+        sendJson(res, 200, { created: `${path}/` });
+        return;
+      }
+      case "download": {
+        const path = normalizePath(body.path);
+        if (!path) return bad("path is required");
+        const file = objFile(bucket, path);
+        if (!(0, import_node_fs.existsSync)(file)) return sendJson(res, 404, { error: "File not found" });
+        const buf = (0, import_node_fs.readFileSync)(file);
+        if (buf.length > 8 * 1024 * 1024) {
+          return bad("File is too large to download inline; use getTemporaryUrl instead");
+        }
+        const meta = manifest.get(objKey(bucket, path));
+        sendJson(res, 200, {
+          body: buf.toString("base64"),
+          contentType: meta?.contentType ?? "application/octet-stream",
+          size: buf.length
+        });
+        return;
+      }
+      case "getUrl": {
+        if (bucket !== "public") return bad("getUrl is only available on the public bucket");
+        const path = normalizePath(body.path);
+        if (!path) return bad("path is required");
+        sendJson(res, 200, { url: `${baseUrl}/__storage/public/${path}` });
+        return;
+      }
+      case "getTemporaryUrl": {
+        const path = normalizePath(body.path);
+        if (!path) return bad("path is required");
+        const requested = Number(body.expiresIn);
+        const expiresIn = Number.isFinite(requested) && requested > 0 ? Math.min(Math.floor(requested), 7 * 24 * 60 * 60) : 300;
+        sendJson(res, 200, {
+          url: `${baseUrl}/__storage/${bucket}/${path}?expires=${expiresIn}`,
+          expiresIn
+        });
+        return;
+      }
+      case "presignUpload": {
+        const path = normalizePath(body.path);
+        if (!path) return bad("path is required");
+        const contentType = typeof body.contentType === "string" && body.contentType.length > 0 ? body.contentType : "application/octet-stream";
+        sendJson(res, 200, {
+          url: `${baseUrl}/__storage/${bucket}/${path}?upload=1&contentType=${encodeURIComponent(contentType)}`,
+          key: path,
+          expiresIn: 600
+        });
+        return;
+      }
+      default:
+        bad("Invalid operation");
+    }
+  }
+  async function handleStorageUpload(req, res, raw) {
+    const webReq = new Request(`${baseUrl}/api/v1/storage`, {
+      method: "PUT",
+      headers: nodeHeaders(req),
+      body: new Uint8Array(raw)
+    });
+    let form;
+    try {
+      form = await webReq.formData();
+    } catch {
+      sendJson(res, 400, { error: "Upload requires multipart/form-data with a file field" });
+      return;
+    }
+    const file = form.get("file");
+    if (!(file instanceof File)) {
+      sendJson(res, 400, { error: "file and path are required" });
+      return;
+    }
+    const bucket = form.get("bucket");
+    if (bucket !== "public" && bucket !== "private") {
+      sendJson(res, 400, { error: 'bucket must be "public" or "private"' });
+      return;
+    }
+    const path = normalizePath(form.get("path"));
+    if (!path) {
+      sendJson(res, 400, { error: "file and path are required" });
+      return;
+    }
+    const ctField = form.get("contentType");
+    const contentType = typeof ctField === "string" && ctField.length > 0 ? ctField : file.type || "application/octet-stream";
+    const buf = Buffer.from(await file.arrayBuffer());
+    writeObject(bucket, path, buf, contentType);
+    sendJson(res, 200, { object: objectShape(bucket, path) });
+  }
+  async function handleFileEndpoint(req, res, url, method) {
+    const rest = url.pathname.slice("/__storage/".length);
+    const slash = rest.indexOf("/");
+    const bucket = slash === -1 ? rest : rest.slice(0, slash);
+    const path = slash === -1 ? "" : rest.slice(slash + 1);
+    if (bucket !== "public" && bucket !== "private" || !path) {
+      sendJson(res, 404, { error: "Not found" });
+      return;
+    }
+    if (method === "PUT" && url.searchParams.get("upload") === "1") {
+      const buf2 = await readBody(req);
+      const contentType = url.searchParams.get("contentType") || (typeof req.headers["content-type"] === "string" ? req.headers["content-type"] : "application/octet-stream");
+      writeObject(bucket, decodeURIComponent(path), buf2, contentType);
+      res.writeHead(200, { "Access-Control-Allow-Origin": "*" });
+      res.end();
+      return;
+    }
+    const file = objFile(bucket, decodeURIComponent(path));
+    if (!(0, import_node_fs.existsSync)(file)) {
+      sendJson(res, 404, { error: "File not found" });
+      return;
+    }
+    const meta = manifest.get(objKey(bucket, decodeURIComponent(path)));
+    const buf = (0, import_node_fs.readFileSync)(file);
+    res.writeHead(200, {
+      "Content-Type": meta?.contentType ?? "application/octet-stream",
+      "Content-Length": buf.length,
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.end(buf);
+  }
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  const actualPort = address && typeof address === "object" ? address.port : port;
+  baseUrl = `http://localhost:${actualPort}`;
+  if (!quiet) {
+    const where = ephemeral ? "ephemeral (in-memory)" : dataDir;
+    console.log(
+      `
+  DontCode mock gateway listening on ${baseUrl}
+  data: ${where}
+
+  Point your app at it:
+    DONTCODE_API_URL=${baseUrl}
+    DONTCODE_API_KEY=dc_local_dev
+`
+    );
+  }
+  return {
+    url: baseUrl,
+    port: actualPort,
+    close: async () => {
+      await new Promise((resolve) => server.close(() => resolve()));
+      await pg.close?.();
+      if (ephemeral) (0, import_node_fs.rmSync)(dataDir, { recursive: true, force: true });
+    }
+  };
+}
+function parseJson(raw) {
+  if (raw.length === 0) return {};
+  try {
+    const parsed = JSON.parse(raw.toString("utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function nodeHeaders(req) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) headers.set(key, value.join(", "));
+    else if (typeof value === "string") headers.set(key, value);
+  }
+  return headers;
+}
+async function loadPGlite() {
+  try {
+    return await import("@electric-sql/pglite");
+  } catch {
+    throw new Error(
+      "The DontCode mock needs an in-process Postgres engine that is not installed.\n  Install it with:  pnpm add -D @electric-sql/pglite   (or npm i -D @electric-sql/pglite)\n  It ships as an optional dependency of @dontcode2/backend, so this usually means\n  it was skipped (e.g. an install run with --no-optional)."
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startMockServer
+});
+//# sourceMappingURL=index.cjs.map