deploro 0.7.0 → 0.9.0

package/dist/index.js

@@ -230,6 +230,10 @@ Downloading ${keys.length} file(s) to ${opts.storage} \u2026`);
   }
 }
 
+// src/commands/gen.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+
 // src/lib/api.ts
 function errorMessage(status, body, statusText) {
   const parts = [body.error ?? statusText];
@@ -268,6 +272,237 @@ async function apiRequestNoProject(path, options) {
   return res.json();
 }
 
+// src/lib/gen-types.ts
+var STRING_NUMERIC = /* @__PURE__ */ new Set(["int8", "numeric", "money"]);
+var NUMBER = /* @__PURE__ */ new Set(["int2", "int4", "float4", "float8", "oid", "xid", "cid", "regclass", "regproc", "regtype"]);
+var STRING = /* @__PURE__ */ new Set([
+  "text",
+  "varchar",
+  "bpchar",
+  "char",
+  "name",
+  "citext",
+  "uuid",
+  "inet",
+  "cidr",
+  "macaddr",
+  "macaddr8",
+  "date",
+  "time",
+  "timetz",
+  "timestamp",
+  "timestamptz",
+  "interval",
+  "xml",
+  "tsvector",
+  "tsquery",
+  "bit",
+  "varbit",
+  "point",
+  "line",
+  "lseg",
+  "box",
+  "path",
+  "polygon",
+  "circle",
+  "ltree"
+]);
+var DATA_TYPE_TO_UDT = {
+  smallint: "int2",
+  integer: "int4",
+  bigint: "int8",
+  real: "float4",
+  "double precision": "float8",
+  numeric: "numeric",
+  money: "money",
+  boolean: "bool",
+  text: "text",
+  "character varying": "varchar",
+  character: "bpchar",
+  uuid: "uuid",
+  json: "json",
+  jsonb: "jsonb",
+  date: "date",
+  bytea: "bytea",
+  "timestamp without time zone": "timestamp",
+  "timestamp with time zone": "timestamptz",
+  "time without time zone": "time",
+  "time with time zone": "timetz",
+  interval: "interval"
+};
+var IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function key(name) {
+  return IDENT_RE.test(name) ? name : JSON.stringify(name);
+}
+function literal(value) {
+  return JSON.stringify(value);
+}
+function udtOf(prop) {
+  if (prop["x-pg-type"]) return prop["x-pg-type"];
+  const dataType = prop.description?.replace(/ NOT NULL$/, "");
+  return dataType ? DATA_TYPE_TO_UDT[dataType] ?? null : null;
+}
+function tsType(udt, enums, write, prop) {
+  if (udt?.startsWith("_")) {
+    const inner = tsType(udt.slice(1), enums, write);
+    return /[|\s]/.test(inner) ? `(${inner})[]` : `${inner}[]`;
+  }
+  if (udt && enums[udt]) return `Database["public"]["Enums"][${literal(udt)}]`;
+  if (udt === "bool") return "boolean";
+  if (udt === "json" || udt === "jsonb") return "Json";
+  if (udt && NUMBER.has(udt)) return "number";
+  if (udt && STRING_NUMERIC.has(udt)) return write ? "number | string" : "string";
+  if (udt && STRING.has(udt)) return "string";
+  if (udt === "void") return "undefined";
+  if (prop?.enum?.length) return prop.enum.map(literal).join(" | ");
+  const t = Array.isArray(prop?.type) ? null : prop?.type;
+  if (t === "number" || t === "integer") return "number";
+  if (t === "boolean") return "boolean";
+  if (t === "string") return "string";
+  if (t === "array") return "unknown[]";
+  return "unknown";
+}
+function generateTypes(spec) {
+  const schemas = spec.components?.schemas ?? {};
+  const enums = spec.components?.["x-pg-enums"] ?? {};
+  const tableNames = Object.keys(schemas).sort();
+  let legacySpec = false;
+  const tableBlocks = [];
+  for (const table2 of tableNames) {
+    const schema = schemas[table2];
+    const required = new Set(schema.required ?? []);
+    const row = [];
+    const insert = [];
+    const update = [];
+    for (const [col, prop] of Object.entries(schema.properties ?? {})) {
+      if (!("x-pg-type" in prop)) legacySpec = true;
+      const nullable = prop.nullable === true || !required.has(col);
+      const udt = udtOf(prop);
+      const readType = tsType(udt, enums, false, prop) + (nullable ? " | null" : "");
+      const writeType = tsType(udt, enums, true, prop) + (nullable ? " | null" : "");
+      const neverWritten = prop["x-pg-generated"] === true || prop["x-pg-identity"] === "always";
+      const optionalOnInsert = nullable || prop["x-pg-has-default"] === true;
+      row.push(`          ${key(col)}: ${readType}`);
+      if (neverWritten) {
+        insert.push(`          ${key(col)}?: never`);
+        update.push(`          ${key(col)}?: never`);
+      } else {
+        insert.push(`          ${key(col)}${optionalOnInsert ? "?" : ""}: ${writeType}`);
+        update.push(`          ${key(col)}?: ${writeType}`);
+      }
+    }
+    const body = (lines) => lines.length ? `{
+${lines.join("\n")}
+        }` : "Record<string, never>";
+    tableBlocks.push(
+      `      ${key(table2)}: {
+        Row: ${body(row)}
+        Insert: ${body(insert)}
+        Update: ${body(update)}
+      }`
+    );
+  }
+  const functionBlocks = [];
+  const fnEntries = Object.entries(spec.paths ?? {}).map(([path, ops]) => ({ name: path.match(/\/studio\/rpc\/([^/]+)$/)?.[1], op: ops.post })).filter((f) => !!f.name && !!f.op).filter((f) => !["trigger", "event_trigger"].includes(f.op["x-pg-returns"]?.type ?? "")).sort((a, b) => a.name.localeCompare(b.name));
+  for (const { name, op } of fnEntries) {
+    const props = op.requestBody?.content?.["application/json"]?.schema?.properties ?? {};
+    const args = Object.entries(props).map(([arg, prop]) => {
+      const optional = prop["x-pg-has-default"] === true;
+      return `          ${key(arg)}${optional ? "?" : ""}: ${tsType(udtOf(prop), enums, true, prop)}`;
+    });
+    const ret = op["x-pg-returns"];
+    let returns;
+    if (!ret) {
+      legacySpec = true;
+      returns = "unknown";
+    } else {
+      let single;
+      if (ret.columns?.length) {
+        single = `{
+${ret.columns.map((c) => `            ${key(c.name)}: ${tsType(c.type, enums, false)} | null`).join("\n")}
+          }`;
+      } else if (ret.type && schemas[ret.type]) {
+        single = `Database["public"]["Tables"][${literal(ret.type)}]["Row"]`;
+      } else {
+        single = tsType(ret.type, enums, false);
+      }
+      returns = ret.set ? /[|\s]/.test(single) && !single.startsWith("{") ? `(${single})[]` : `${single}[]` : single;
+    }
+    functionBlocks.push(
+      `      ${key(name)}: {
+        Args: ${args.length ? `{
+${args.join("\n")}
+        }` : "Record<PropertyKey, never>"}
+        Returns: ${returns}
+      }`
+    );
+  }
+  const enumBlocks = Object.keys(enums).sort().map(
+    (name) => `      ${key(name)}: ${enums[name].length ? enums[name].map(literal).join(" | ") : "never"}`
+  );
+  const section = (blocks) => blocks.length ? `{
+${blocks.join("\n")}
+    }` : "{\n      [_ in never]: never\n    }";
+  const source = `// Generated by \`deploro gen types\`. Do not edit by hand; re-run after each migration.
+//
+// bigint, numeric and money columns are strings in Row: Deploro returns them as
+// strings so large values keep their precision. Insert and Update accept either.
+
+export type Json =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: Json | undefined }
+  | Json[]
+
+export type Database = {
+  public: {
+    Tables: ${section(tableBlocks)}
+    Functions: ${section(functionBlocks)}
+    Enums: ${section(enumBlocks)}
+  }
+}
+
+type PublicSchema = Database["public"]
+
+export type Tables<T extends keyof PublicSchema["Tables"]> = PublicSchema["Tables"][T]["Row"]
+export type TablesInsert<T extends keyof PublicSchema["Tables"]> = PublicSchema["Tables"][T]["Insert"]
+export type TablesUpdate<T extends keyof PublicSchema["Tables"]> = PublicSchema["Tables"][T]["Update"]
+export type Enums<T extends keyof PublicSchema["Enums"]> = PublicSchema["Enums"][T]
+export type FunctionArgs<T extends keyof PublicSchema["Functions"]> = PublicSchema["Functions"][T]["Args"]
+export type FunctionReturns<T extends keyof PublicSchema["Functions"]> = PublicSchema["Functions"][T]["Returns"]
+`;
+  return {
+    source,
+    tables: tableNames.length,
+    functions: fnEntries.length,
+    enums: enumBlocks.length,
+    legacySpec
+  };
+}
+
+// src/commands/gen.ts
+async function genTypesCommand(opts) {
+  const config = requireProject();
+  const spec = await apiRequest(`/api/projects/${config.projectId}/studio/spec`);
+  const result = generateTypes(spec);
+  if (opts.out) {
+    mkdirSync3(dirname3(opts.out) || ".", { recursive: true });
+    writeFileSync3(opts.out, result.source, "utf8");
+    console.error(
+      `Wrote ${opts.out}: ${result.tables} table(s), ${result.functions} function(s), ${result.enums} enum(s)`
+    );
+  } else {
+    process.stdout.write(result.source);
+  }
+  if (result.legacySpec) {
+    console.error(
+      "Warning: this server's spec has no column defaults or function return types, so every NOT NULL column is required in Insert and function Returns are `unknown`. They'll be exact once the server is updated."
+    );
+  }
+}
+
 // src/lib/confirm.ts
 import { createInterface as createInterface2 } from "readline";
 async function confirmOrDie(question, yes) {
@@ -444,6 +679,36 @@ async function dbDropTableCommand(tableName, opts) {
   await apiRequest(`/api/db/tables/${encodeURIComponent(tableName)}`, { method: "DELETE" });
   console.log(`\u2713 Table "${tableName}" dropped`);
 }
+var SEVERITY_LABEL = {
+  error: "SECURITY",
+  warning: "WARNING",
+  info: "SUGGEST"
+};
+async function dbAdvisorsCommand(opts) {
+  const config = requireProject();
+  const data = await apiRequestNoProject(
+    `/api/projects/${config.projectId}/database/advisors`
+  );
+  if (opts.json) {
+    json(data.findings);
+    return;
+  }
+  if (data.findings.length === 0) {
+    console.log("\u2713 No problems found. RLS, primary keys and foreign-key indexes all look right.");
+    return;
+  }
+  for (const f of data.findings) {
+    console.log(`
+[${SEVERITY_LABEL[f.severity]}] ${f.table}: ${f.title}`);
+    console.log(`  ${f.detail}`);
+    if (f.fix) console.log(`  Fix: ${f.fix}`);
+  }
+  const errors = data.findings.filter((f) => f.severity === "error").length;
+  console.log(`
+${data.findings.length} finding${data.findings.length === 1 ? "" : "s"}${errors ? `, ${errors} security` : ""}.`);
+  console.log("Fix SQL is never run for you. Apply it as a migration (deploro migrate).");
+  if (errors) process.exitCode = 1;
+}
 
 // src/commands/auth.ts
 function isPatToken(accessToken) {
@@ -905,7 +1170,7 @@ async function resolveDomainId(projectId, idOrHostname) {
 }
 
 // src/commands/zones.ts
-import { writeFileSync as writeFileSync3 } from "fs";
+import { writeFileSync as writeFileSync4 } from "fs";
 function zonesPath() {
   return `/api/projects/${requireProject().projectId}/zones`;
 }
@@ -975,7 +1240,7 @@ async function zonesRemoveCommand(domain, opts) {
   });
   if (data.zone_file) {
     const file = `${z.name}.zone.txt`;
-    writeFileSync3(file, data.zone_file);
+    writeFileSync4(file, data.zone_file);
     console.log(`Saved its records to ${file}`);
   }
   console.log(`\u2713 ${z.name} removed`);
@@ -1170,7 +1435,7 @@ async function zonesUnforwardCommand(address) {
 }
 
 // src/commands/storage.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
 import { basename } from "path";
 function authHeaders2(config) {
   return { Authorization: `Bearer ${config.accessToken}` };
@@ -1213,27 +1478,27 @@ async function storageUploadCommand(filePath, opts) {
   const data = await res.json();
   console.log(`\u2713 Uploaded as ${data.key} (${data.size} bytes, ${data.contentType})`);
 }
-async function storageDownloadCommand(key, opts) {
+async function storageDownloadCommand(key2, opts) {
   const config = requireProject();
   const res = await fetch(
-    `${config.baseUrl}/api/projects/${config.projectId}/storage/download?key=${encodeURIComponent(key)}`,
+    `${config.baseUrl}/api/projects/${config.projectId}/storage/download?key=${encodeURIComponent(key2)}`,
     { headers: authHeaders2(config) }
   );
   await throwOnError2(res);
   const bytes = new Uint8Array(await res.arrayBuffer());
-  const outPath = opts.out ?? basename(key);
-  writeFileSync4(outPath, bytes);
+  const outPath = opts.out ?? basename(key2);
+  writeFileSync5(outPath, bytes);
   console.log(`\u2713 Saved to ${outPath} (${bytes.length} bytes)`);
 }
-async function storageDeleteCommand(key, opts) {
+async function storageDeleteCommand(key2, opts) {
   const config = requireProject();
-  await confirmOrDie(`Delete "${key}" from storage?`, opts.yes);
+  await confirmOrDie(`Delete "${key2}" from storage?`, opts.yes);
   const res = await fetch(
-    `${config.baseUrl}/api/projects/${config.projectId}/storage?key=${encodeURIComponent(key)}`,
+    `${config.baseUrl}/api/projects/${config.projectId}/storage?key=${encodeURIComponent(key2)}`,
     { method: "DELETE", headers: authHeaders2(config) }
   );
   await throwOnError2(res);
-  console.log(`\u2713 Deleted ${key}`);
+  console.log(`\u2713 Deleted ${key2}`);
 }
 async function storagePublicCommand(mode, opts) {
   const config = requireProject();
@@ -1335,13 +1600,13 @@ function parseDuration(input) {
   const mult = { s: 1, m: 60, h: 3600, d: 86400 }[unit] ?? 1;
   return n * mult;
 }
-async function storageSignCommand(key, opts) {
+async function storageSignCommand(key2, opts) {
   const config = requireProject();
   const expiresIn = opts.expires ? parseDuration(opts.expires) : void 0;
   const res = await fetch(`${config.baseUrl}/api/projects/${config.projectId}/storage/signed-url`, {
     method: "POST",
     headers: { ...authHeaders2(config), "Content-Type": "application/json" },
-    body: JSON.stringify({ key, expiresIn })
+    body: JSON.stringify({ key: key2, expiresIn })
   });
   await throwOnError2(res);
   const data = await res.json();
@@ -1598,13 +1863,13 @@ async function hostingStatusCommand() {
   }
   console.log("");
 }
-async function hostingSetEnvCommand(key, value) {
+async function hostingSetEnvCommand(key2, value) {
   requireConfig();
   await apiRequest("/api/hosting/env", {
     method: "POST",
-    body: JSON.stringify({ key, value })
+    body: JSON.stringify({ key: key2, value })
   });
-  console.log(`\u2713 Secret '${key}' updated`);
+  console.log(`\u2713 Secret '${key2}' updated`);
 }
 async function hostingEnvCommand() {
   requireConfig();
@@ -1942,13 +2207,13 @@ async function vpsEnvCommand() {
   for (const v of data.vars) console.log(`  ${v.key}`);
   console.log("");
 }
-async function vpsSetEnvCommand(key, value) {
+async function vpsSetEnvCommand(key2, value) {
   const config = requireProject();
   await apiRequest(`/api/projects/${config.projectId}/vps/env`, {
     method: "POST",
-    body: JSON.stringify({ key, value })
+    body: JSON.stringify({ key: key2, value })
   });
-  console.log(`\u2713 VPS env var '${key}' set \u2014 run 'deploro vps deploy' to apply it`);
+  console.log(`\u2713 VPS env var '${key2}' set \u2014 run 'deploro vps deploy' to apply it`);
 }
 async function vpsDeployCommand() {
   const config = requireProject();
@@ -2086,12 +2351,15 @@ program.command("create <name>").description("Create a new project (and set it a
 program.command("use <project>").description("Set the active project (accepts id, slug, or name)").action(useProjectCommand);
 program.command("delete <project>").description("Delete a project and its database (accepts id, slug, or name)").option("-y, --yes", "Skip confirmation prompt").action(projectsDeleteCommand);
 program.command("export").description("Export the active project's database and storage manifest (NDJSON)").option("--out <file>", "Where to write the export (default: deploro-export-<date>.ndjson)").option("--storage <dir>", "Also download stored files into this directory").option("--skip-storage", "Skip the object-storage listing entirely").action(exportCommand);
+var gen = program.command("gen").description("Generate code from the active project");
+gen.command("types").description("TypeScript types for the project's tables, functions and enums (prints to stdout)").option("--out <file>", "Write to this file instead of stdout").action(genTypesCommand);
 var db = program.command("db").description("Database commands");
 db.command("create").description("Provision the active project's database (idempotent)").action(dbCreateCommand);
 db.command("info").description("Show database status and how to reach it from a deployed app").action(dbInfoCommand);
 db.command("tables").description("List tables in the active project").action(dbTablesCommand);
 db.command("rows <table>").description("List rows in a table").option("--limit <n>", "Rows per page (max 200)", "20").option("--page <n>", "Page number", "1").option("--json", "Output raw JSON").action(dbRowsCommand);
 db.command("query <sql>").description("Run a read-only SQL query (project admin)").option("--param <value>", "Bind a value to $1, $2, ... in order (repeatable)", (v, prev) => [...prev, v], []).option("--json", "Output raw JSON").action(dbQueryCommand);
+db.command("advisors").description("Run database checks: RLS exposure, missing policies, primary keys, foreign-key indexes").option("--json", "Output raw JSON").action(dbAdvisorsCommand);
 db.command("schema <table>").description("Show schema for a table").action(dbSchemaCommand);
 db.command("insert <table>").description("Insert a row").requiredOption("--data <json>", "Row data as a JSON object").action(dbInsertCommand);
 db.command("update <table> <id>").description("Update a row by id").requiredOption("--data <json>", "Fields to update as a JSON object").action(dbUpdateCommand);

package/package.json

@@ -1,44 +1,44 @@
-{
-  "name": "deploro",
-  "version": "0.7.0",
-  "description": "Command-line interface for the Deploro developer platform — manage projects, databases, deployments, and hosting from your terminal.",
-  "type": "module",
-  "bin": {
-    "deploro": "dist/index.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "keywords": [
-    "deploro",
-    "cli",
-    "cloudflare",
-    "postgres",
-    "deployment"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yawdeals1/deploro.git",
-    "directory": "packages/cli"
-  },
-  "homepage": "https://deploro.com",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --no-splitting --target node18 --out-dir dist",
-    "dev": "tsup src/index.ts --format esm --no-splitting --target node18 --out-dir dist --watch"
-  },
-  "dependencies": {
-    "commander": "^13.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "tsup": "^8.0.0",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "deploro",
+  "version": "0.9.0",
+  "description": "Command-line interface for the Deploro developer platform — manage projects, databases, deployments, and hosting from your terminal.",
+  "type": "module",
+  "bin": {
+    "deploro": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "deploro",
+    "cli",
+    "cloudflare",
+    "postgres",
+    "deployment"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yawdeals1/deploro.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://deploro.com",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --no-splitting --target node18 --out-dir dist",
+    "dev": "tsup src/index.ts --format esm --no-splitting --target node18 --out-dir dist --watch"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  }
+}