@devmoods/postgres-admin 0.2.0

package/dist/client/index.html

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="no">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="shortcut icon" href="/favicon.ico" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, shrink-to-fit=no"
+    />
+    <meta name="theme-color" content="#000000" />
+    <link rel="manifest" href="/manifest.json" />
+    <title>Posterboi</title>
+    <script type="module" crossorigin src="/admin/assets/index-D9Xb7F16.js"></script>
+    <link rel="stylesheet" crossorigin href="/admin/assets/index-BQSpf7B-.css">
+  </head>
+  <body>
+    <div id="root"></div>
+
+  </body>
+</html>

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import * as express_serve_static_core from 'express-serve-static-core';
+import { createPostgres } from '@devmoods/express-extras';
+
+interface AdminRouterOptions {
+    postgres: ReturnType<typeof createPostgres>;
+}
+declare function createRouter({ postgres }: AdminRouterOptions): express_serve_static_core.Router;
+
+declare const admin: typeof createRouter;
+
+export { admin };

package/dist/index.js

@@ -0,0 +1,442 @@
+// src/api/app.ts
+import * as path from "node:path";
+import {
+  BadRequest,
+  joinStatements,
+  route,
+  sql,
+  validateQuery
+} from "@devmoods/express-extras";
+import express from "express";
+
+// src/api/structure.ts
+import "@bitiforms/react";
+import { NotFound, readEnv } from "@devmoods/express-extras";
+import "pg-structure";
+import { pgStructure } from "pg-structure/dist/main.js";
+
+// src/types.ts
+import "@bitiforms/react";
+
+// src/api/structure.ts
+var getDisplayType = (dbType) => {
+  switch (dbType) {
+    case "jsonb":
+    case "json":
+      return "json";
+    case "character varying":
+    case "text":
+    case "tstzrange":
+    case "bytea":
+    case "uuid":
+      return "string";
+    case "date":
+      return "date";
+    case "timestamp without time zone":
+    case "timestamp with time zone":
+      return "datetime";
+    case "integer":
+    case "numeric":
+    case "smallint":
+    case "bigint":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+};
+var getPrimitiveType = (dbType) => {
+  switch (dbType) {
+    case "character varying":
+    case "timestamp without time zone":
+    case "timestamp with time zone":
+    case "text":
+    case "date":
+    case "jsonb":
+    case "tstzrange":
+    case "bytea":
+    case "uuid":
+      return "string";
+    case "integer":
+    case "numeric":
+    case "smallint":
+    case "bigint":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+};
+function stripStringValue(value) {
+  if (value.startsWith("nextval(")) {
+    return null;
+  }
+  if (value.includes("now()")) {
+    return null;
+  }
+  return value.slice(1, -1);
+}
+function getDefault(value) {
+  if (typeof value === "string") {
+    return stripStringValue(value);
+  }
+  return value;
+}
+function toJsonSchemaProperty(column) {
+  const defaultValue = getDefault(column.default);
+  const type = getPrimitiveType(column.type.name);
+  const description = column.comment;
+  if (column.arrayDimension > 0) {
+    return {
+      type: "array",
+      title: column.name,
+      items: { type },
+      default: defaultValue || [],
+      description
+    };
+  }
+  const $bitiforms = {};
+  if (column.isForeignKey) {
+    $bitiforms.widget = "ForeignKeyWidget";
+    $bitiforms.widgetProps = {
+      foreignTable: column.foreignKeys.at(0)?.referencedTable.name,
+      foreignColumn: column.foreignKeys.at(0)?.referencedColumns.at(0)?.name
+    };
+  }
+  return {
+    type,
+    title: column.name,
+    default: defaultValue,
+    description,
+    $bitiforms
+  };
+}
+var tableCache = /* @__PURE__ */ new Map();
+function toJsonSchema(table) {
+  const required = [];
+  const properties = {};
+  for (const column of table.columns) {
+    properties[column.name] = toJsonSchemaProperty(column);
+    if (column.notNull && !column.isSerial) {
+      required.push(column.name);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required
+  };
+}
+async function getTable(tableId) {
+  if (!tableCache.has(tableId)) {
+    const tables = await readTables();
+    for (const table of tables) {
+      tableCache.set(table.tableName, table);
+    }
+  }
+  const value = tableCache.get(tableId);
+  if (value == null) {
+    throw NotFound();
+  }
+  return value;
+}
+async function readTables() {
+  const structure = await pgStructure({
+    connectionString: readEnv("POSTGRES_URL")
+  });
+  const toMetadata = (column) => ({
+    type: getPrimitiveType(column.type.name),
+    displayType: getDisplayType(column.type.name),
+    dbType: column.type.name,
+    foreignKeys: column.foreignKeys.mapToArray((fk) => ({
+      table: fk.referencedTable.name,
+      column: fk.referencedColumns.at(0).name
+    }))
+  });
+  const toBelongsTo = (table) => {
+    return table.belongsToTables.mapToArray((t) => {
+      const foreignKey = t.getForeignKeysFrom(table.name).mapToArray((fk) => fk.columns.at(0)?.name).at(0);
+      const belongsToTableColumns = t.columns.mapToArray((c) => c.name);
+      return {
+        foreignKey,
+        belongsToTable: t.name,
+        includeColumnNames: belongsToTableColumns.map(
+          (c) => `${foreignKey.replace(/_id$/, "")}__${c}`
+        )
+      };
+    });
+  };
+  const result = [];
+  for (const table of structure.tables) {
+    const belongsTo = toBelongsTo(table);
+    const columnsArray = table.columns.mapToArray((column) => column);
+    result.push({
+      tableName: table.name,
+      primaryKey: table.primaryKey?.columns.at(0)?.name ?? null,
+      belongsTo,
+      columnNames: columnsArray.map((column) => column.name),
+      relatedColumnNames: belongsTo.flatMap((b) => b.includeColumnNames),
+      columnMetadata: Object.fromEntries(
+        columnsArray.map((column) => [column.name, toMetadata(column)])
+      ),
+      schema: toJsonSchema(table)
+    });
+  }
+  return result;
+}
+
+// src/api/utils.ts
+function stripIdentifier(tableName) {
+  return (tableName ?? "").replace(/[^\w+]/g, "");
+}
+function parseOrderBy(order) {
+  if (!order) {
+    return null;
+  }
+  const direction = order.at(0) === "-" ? "DESC" : "ASC";
+  const column = order.at(0) === "-" ? order.slice(1) : order;
+  return { direction, column };
+}
+function queryParamToArray(queryParam) {
+  if (Array.isArray(queryParam)) {
+    return queryParam.filter((value) => typeof value === "string");
+  }
+  if (typeof queryParam === "string") {
+    return [queryParam];
+  }
+  return [];
+}
+
+// src/api/app.ts
+function createRouter({ postgres }) {
+  const app = express.Router();
+  app.get(
+    "/api/tables",
+    route(async () => {
+      const tables = await readTables();
+      const rowCounts = Object.fromEntries(
+        await Promise.all(
+          tables.map(async (table) => {
+            return [
+              table.tableName,
+              await postgres.get(sql`SELECT COUNT(*) FROM ${sql.identifier(table.tableName)}`).then((r) => r.count)
+            ];
+          })
+        )
+      );
+      return {
+        tables,
+        rowCounts
+      };
+    })
+  );
+  app.get(
+    "/api/tables/:table/suggestions/:column",
+    route(async (req) => {
+      const table = stripIdentifier(req.params.table);
+      const definition = await getTable(table);
+      const column = stripIdentifier(req.params.column);
+      if (!definition.columnNames.includes(column)) {
+        throw BadRequest(
+          `Invalid colimn ${column}. Must be one of: ${definition.columnNames.join(", ")}`
+        );
+      }
+      const statement = sql`
+      SELECT DISTINCT ${sql.identifier(column)}, *
+      FROM ${sql.identifier(table)}
+      LIMIT 20
+    `;
+      return postgres.all(statement);
+    })
+  );
+  app.get(
+    "/api/tables/:table",
+    validateQuery({
+      type: "object",
+      properties: {
+        order: {
+          oneOf: [
+            { type: "string" },
+            { type: "array", items: { type: "string" } }
+          ]
+        },
+        limit: { type: "number", minimum: 1, maximum: 1e3 },
+        page: { type: "number" },
+        search: { type: "string" }
+      },
+      required: []
+    }),
+    route(async (req) => {
+      const table = stripIdentifier(req.params.table);
+      const orders = queryParamToArray(req.query.order);
+      const limit = parseInt(req.query.limit ?? "50");
+      const page = parseInt(req.query.page ?? "1");
+      const search = String(req.query.search || "");
+      const definition = await getTable(table);
+      const orderBy = orders.map((order) => parseOrderBy(order)).filter((x) => x != null);
+      const allowedColumnNames = definition.columnNames.concat(
+        definition.relatedColumnNames
+      );
+      if (orderBy && !orderBy.every((x) => allowedColumnNames.includes(x.column))) {
+        throw BadRequest(
+          `Invalid order value ${orderBy.map((x) => x.column).join(", ")}. Must be one of: ${allowedColumnNames.join(", ")}`
+        );
+      }
+      const fieldsToSelect = [sql`${sql.identifier(table)}.*`];
+      const foreignTables = Object.fromEntries(
+        await Promise.all(
+          definition.columnNames.flatMap((column) => {
+            const metadata = definition.columnMetadata[column];
+            return metadata.foreignKeys.map((x) => x.table);
+          }).map(async (t) => [t, await getTable(t)])
+        )
+      );
+      const joins = [];
+      for (const column of definition.columnNames) {
+        const metadata = definition.columnMetadata[column];
+        for (const {
+          table: fkTable,
+          column: fkColumn
+        } of metadata.foreignKeys) {
+          const foreignColumns = foreignTables[fkTable].columnNames;
+          const prefix = column.replace(/_id$/, "");
+          for (const foreignColumn of foreignColumns) {
+            fieldsToSelect.push(
+              sql`${sql.identifier(fkTable)}.${sql.identifier(foreignColumn)} AS ${sql.identifier(`${prefix}__${foreignColumn}`)}`
+            );
+          }
+          joins.push(
+            sql`LEFT JOIN ${sql.identifier(fkTable)} ON ${sql.identifier(fkTable)}.${sql.identifier(fkColumn)} = ${sql.identifier(table)}.${sql.identifier(column)}`
+          );
+        }
+      }
+      const statement = sql`SELECT ${joinStatements(fieldsToSelect, ", ")} FROM ${sql.identifier(table)} ${joinStatements(joins, " ")}`;
+      if (search && search.length > 2) {
+        statement.append(" WHERE ");
+        statement.append(
+          joinStatements(
+            definition.columnNames.map(
+              (c) => sql`${sql.identifier(c)}::text ILIKE ${`%${search}%`}`
+            ),
+            " OR "
+          )
+        );
+      }
+      if (orderBy.length > 0) {
+        statement.append(sql` ORDER BY `);
+        statement.append(
+          joinStatements(
+            orderBy.map(
+              (o) => sql`${sql.identifier(o.column)} ${sql.raw(o.direction)}`
+            ),
+            ", "
+          )
+        );
+      } else if (definition.primaryKey) {
+        statement.append(
+          sql` ORDER BY ${sql.identifier(definition.primaryKey)}`
+        );
+      }
+      statement.append(sql` LIMIT ${limit} OFFSET ${limit * (page - 1)}`);
+      return await postgres.all(statement);
+    })
+  );
+  app.get(
+    "/api/tables/:table/:pk",
+    route(async (req) => {
+      const table = stripIdentifier(req.params.table);
+      const definition = await getTable(table);
+      const primaryKey = definition.primaryKey;
+      if (!primaryKey) {
+        throw BadRequest(`Table ${table} has no primary key`);
+      }
+      const statement = sql`
+      SELECT *
+      FROM ${sql.identifier(table)}
+      WHERE ${sql.identifier(primaryKey)} = ${req.params.pk}
+    `;
+      return postgres.first(statement);
+    })
+  );
+  app.post(
+    "/api/tables/:table",
+    route(async (req) => {
+      const table = stripIdentifier(req.params.table);
+      const definition = await getTable(table);
+      const primaryKey = definition.primaryKey;
+      if (!primaryKey) {
+        throw BadRequest(`Table ${table} has no primary key`);
+      }
+      const { [primaryKey]: pk, ...data } = req.body;
+      const statement = sql`
+      INSERT INTO ${sql.identifier(table)}
+      ${sql.spreadInsert(data)}
+    `;
+      return postgres.first(statement);
+    })
+  );
+  app.put(
+    "/api/tables/:table/:pk",
+    route(async (req) => {
+      const table = stripIdentifier(req.params.table);
+      const pk = req.params.pk;
+      const definition = await getTable(table);
+      const primaryKey = definition.primaryKey;
+      if (!primaryKey) {
+        throw BadRequest(`Table ${table} has no primary key`);
+      }
+      return await postgres.transaction(async (tx) => {
+        await postgres.get(sql`
+        SELECT * FROM ${sql.identifier(table)}
+        WHERE ${sql.identifier(primaryKey)} = ${req.params.pk}
+        FOR UPDATE
+      `);
+        return tx.get(sql`
+        UPDATE ${sql.identifier(table)}
+        SET ${sql.spreadUpdate(req.body)}
+        WHERE ${sql.identifier(primaryKey)} = ${pk}
+        RETURNING *
+      `);
+      });
+    })
+  );
+  app.delete(
+    "/api/tables/:table/:pk",
+    route(async (req) => {
+      const table = stripIdentifier(req.params.table);
+      const pk = parseInt(req.params.pk);
+      const definition = await getTable(table);
+      const primaryKey = definition.primaryKey;
+      if (!primaryKey) {
+        throw BadRequest(`Table ${table} has no primary key`);
+      }
+      const statement = sql`
+      DELETE FROM ${sql.identifier(table)}
+      WHERE ${sql.identifier(primaryKey)} = ${pk}
+    `;
+      await postgres.query(statement);
+      return 204;
+    })
+  );
+  app.use(
+    express.static(
+      path.resolve("node_modules/@devmoods/postgres-admin/dist/client")
+    )
+  );
+  app.get("*", (req, res) => {
+    res.sendFile(
+      path.resolve(
+        "node_modules/@devmoods/postgres-admin/dist/client/index.html"
+      )
+    );
+  });
+  return app;
+}
+
+// src/index.ts
+var admin = createRouter;
+export {
+  admin
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@devmoods/postgres-admin",
+  "version": "0.2.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@devmoods/express-extras": "^0.42.0",
+    "pg-structure": "^7.15.3"
+  },
+  "devDependencies": {
+    "@bitiforms/adapter-devmoods-ui": "^0.11.0",
+    "@bitiforms/react": "^0.11.0",
+    "@devmoods/fetch": "^4.0.1",
+    "@devmoods/ui": "^2.3.0",
+    "@tanstack/react-query": "^5.62.2",
+    "@types/react": "^18.3.13",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "@vitest/coverage-v8": "2.1.8",
+    "date-fns": "^4.1.0",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.1",
+    "react": "19.0.0-rc-7670501b-20241124",
+    "react-dom": "19.0.0-rc-7670501b-20241124",
+    "react-fast-compare": "^3.2.2",
+    "react-icons": "5.4.0",
+    "react-router": "^7.0.2",
+    "sass": "^1.82.0",
+    "sql-formatter": "^15.4.6",
+    "tsup": "^8.3.5",
+    "vite": "^6.0.2",
+    "vitest": "^2.1.8",
+    "zustand": "^5.0.2"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build:server": "tsup-node src/index.ts --format esm --dts",
+    "build:client": "tsc --noEmit && vite build",
+    "build": "pnpm run build:server && pnpm run build:client",
+    "test": "vitest"
+  }
+}