@devmoods/postgres-admin 0.20.0 → 0.21.0

package/dist/index.js

@@ -3,17 +3,22 @@ import { promises as fs } from "fs";
 import * as path from "path";
 import {
   BadRequest,
-  createPostgres,
+  createPostgres as createPostgres2,
   generateCsrfToken,
   joinStatements,
-  sql,
+  sql as sql2,
   staticMiddleware,
   createRouter
 } from "@devmoods/express-extras";
 import { type } from "arktype";
 
 // src/api/structure.ts
-import { NotFound, readEnv } from "@devmoods/express-extras";
+import {
+  createPostgres,
+  NotFound,
+  readEnv,
+  sql
+} from "@devmoods/express-extras";
 import "pg-structure";
 import { pgStructure } from "pg-structure/dist/main.js";
 var getDisplayType = (dbType) => {
@@ -58,33 +63,40 @@ var getPrimitiveType = (dbType) => {
     case "uuid":
       return "string";
     case "integer":
-    case "numeric":
     case "smallint":
-    case "bigint":
       return "number";
+    case "numeric":
+    case "bigint":
+      return "string";
     case "boolean":
       return "boolean";
     default:
       return "string";
   }
 };
-function stripStringValue(value) {
-  if (value.startsWith("nextval(")) {
-    return null;
+function getDefault(column) {
+  const value = column.default;
+  if (typeof value !== "string") {
+    return value;
   }
-  if (value.includes("now()")) {
-    return null;
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1).replaceAll("''", "'");
   }
-  return value.slice(1, -1);
-}
-function getDefault(value) {
-  if (typeof value === "string") {
-    return stripStringValue(value);
+  if (column.type.name === "boolean") {
+    if (value === "true") {
+      return true;
+    }
+    if (value === "false") {
+      return false;
+    }
   }
-  return value;
+  if (/^[+-]?(?:\d+\.?\d*|\.\d+)$/.test(value)) {
+    return ["numeric", "bigint"].includes(column.type.name) ? value : Number(value);
+  }
+  return void 0;
 }
-function toJsonSchemaProperty(column) {
-  const defaultValue = getDefault(column.default);
+function toJsonSchemaProperty(column, tableId) {
+  const defaultValue = getDefault(column);
   const type2 = getPrimitiveType(column.type.name);
   const description = column.comment;
   if (column.arrayDimension > 0) {
@@ -92,33 +104,38 @@ function toJsonSchemaProperty(column) {
       type: "array",
       title: column.name,
       items: { type: type2 },
-      default: defaultValue || [],
       description
     };
   }
   const $bitiforms = {};
   if (column.isForeignKey) {
+    const foreignKey = column.foreignKeys.at(0);
     $bitiforms.widget = "ForeignKeyWidget";
     $bitiforms.widgetProps = {
-      foreignTable: column.foreignKeys.at(0)?.referencedTable.name,
-      foreignColumn: column.foreignKeys.at(0)?.referencedColumns.at(0)?.name
+      foreignTable: foreignKey ? tableId(foreignKey.referencedTable) : void 0,
+      foreignColumn: foreignKey?.referencedColumns.at(0)?.name,
+      nullable: !column.notNull
     };
   }
   return {
     type: type2,
     title: column.name,
-    default: defaultValue,
+    ...defaultValue === void 0 ? {} : { default: defaultValue },
     description,
     $bitiforms
   };
 }
 var tableCache = /* @__PURE__ */ new Map();
-function toJsonSchema(table) {
+function toJsonSchema(table, tableId, identityColumns) {
   const required = [];
   const properties = {};
   for (const column of table.columns) {
-    properties[column.name] = toJsonSchemaProperty(column);
-    if (column.notNull && !column.isSerial) {
+    const columnId = `${table.schema.name}\0${table.name}\0${column.name}`;
+    if (column.isGenerated || identityColumns.has(columnId)) {
+      continue;
+    }
+    properties[column.name] = toJsonSchemaProperty(column, tableId);
+    if (column.notNull && !column.isSerial && column.default == null) {
       required.push(column.name);
     }
   }
@@ -128,40 +145,70 @@ function toJsonSchema(table) {
     required
   };
 }
-async function getTable(tableId) {
-  if (!tableCache.has(tableId)) {
-    const { tables } = await readTables();
-    for (const table of tables) {
-      tableCache.set(table.tableName, table);
-    }
+async function getTable(tableId, connectionString = readEnv("POSTGRES_URL")) {
+  const cacheKey = `${connectionString}\0${tableId}`;
+  if (!tableCache.has(cacheKey)) {
+    await readTables(connectionString);
   }
-  const value = tableCache.get(tableId);
+  const value = tableCache.get(cacheKey);
   if (value == null) {
     throw NotFound();
   }
   return value;
 }
-async function readTables() {
-  const connectionString = readEnv("POSTGRES_URL");
-  const structure = await pgStructure({
-    connectionString
-  });
+async function readTables(connectionString = readEnv("POSTGRES_URL")) {
+  const [structure, identityRows] = await Promise.all([
+    pgStructure({ connectionString }),
+    (async () => {
+      const postgres = createPostgres({ url: connectionString });
+      try {
+        return await postgres.all(sql`
+          SELECT table_schema, table_name, column_name
+          FROM information_schema.columns
+          WHERE is_identity = 'YES'
+        `);
+      } finally {
+        await postgres.end();
+      }
+    })()
+  ]);
+  const identityColumns = new Set(
+    identityRows.map(
+      (row) => `${row.table_schema}\0${row.table_name}\0${row.column_name}`
+    )
+  );
+  const tableId = (table) => `${table.schema.name}.${table.name}`;
   const toMetadata = (column) => ({
     type: getPrimitiveType(column.type.name),
     displayType: getDisplayType(column.type.name),
     dbType: column.type.name,
-    foreignKeys: column.foreignKeys.mapToArray((fk) => ({
+    hasDefault: column.default != null || column.isSerial,
+    isGenerated: column.isGenerated,
+    isIdentity: identityColumns.has(
+      `${column.table.schema.name}\0${column.table.name}\0${column.name}`
+    ),
+    nullable: !column.notNull,
+    foreignKeys: column.foreignKeys.filter(
+      (fk) => fk.columns.length === 1 && fk.referencedColumns.length === 1
+    ).mapToArray((fk) => ({
       table: fk.referencedTable.name,
+      tableId: tableId(fk.referencedTable),
       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 table.foreignKeys.filter(
+      (fk) => fk.columns.length === 1 && fk.referencedColumns.length === 1
+    ).mapToArray((fk) => {
+      const foreignKey = fk.columns.at(0).name;
+      const referencedTable = fk.referencedTable;
+      const belongsToTableColumns = referencedTable.columns.mapToArray(
+        (c) => c.name
+      );
       return {
         foreignKey,
-        belongsToTable: t.name,
+        belongsToTable: referencedTable.name,
+        belongsToTableId: tableId(referencedTable),
         includeColumnNames: belongsToTableColumns.map(
           (c) => `${foreignKey.replace(/_id$/, "")}__${c}`
         )
@@ -172,18 +219,33 @@ async function readTables() {
   for (const table of structure.tables) {
     const belongsTo = toBelongsTo(table);
     const columnsArray = table.columns.mapToArray((column) => column);
+    const primaryKeyColumns = table.primaryKey?.columns.mapToArray((column) => column.name) ?? [];
     tables.push({
+      tableId: tableId(table),
+      schemaName: table.schema.name,
       tableName: table.name,
-      primaryKey: table.primaryKey?.columns.at(0)?.name ?? null,
+      primaryKey: primaryKeyColumns.length === 1 ? primaryKeyColumns.at(0) : 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)
+      schema: toJsonSchema(table, tableId, identityColumns)
     });
   }
+  const cachePrefix = `${connectionString}\0`;
+  for (const key of tableCache.keys()) {
+    if (key.startsWith(cachePrefix)) {
+      tableCache.delete(key);
+    }
+  }
+  for (const table of tables) {
+    tableCache.set(`${cachePrefix}${table.tableId}`, table);
+    if (table.schemaName === "public") {
+      tableCache.set(`${cachePrefix}${table.tableName}`, table);
+    }
+  }
   return {
     databaseName: new URL(connectionString).pathname.slice(1),
     tables
@@ -191,9 +253,6 @@ async function readTables() {
 }
 
 // src/api/utils.ts
-function stripIdentifier(tableName) {
-  return (tableName ?? "").replace(/[^\w+]/g, "");
-}
 function parseOrderBy(order) {
   if (!order) {
     return null;
@@ -224,32 +283,48 @@ function counter() {
   };
 }
 
+// src/basename.ts
+function normalizeBasename(basename) {
+  return basename.replace(/^\/+|\/+$/g, "");
+}
+
 // src/api/app.ts
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function qualifiedTable(table) {
+  return sql2`${sql2.identifier(table.schemaName)}.${sql2.identifier(table.tableName)}`;
+}
 function createAdminRouter({
   postgres: defaultPostgres,
   basename = "/admin",
   indexHtml = "node_modules/@devmoods/postgres-admin/dist/client/_index.html",
   uiOptions = {}
 }) {
-  const postgres = defaultPostgres ?? createPostgres();
+  const postgres = defaultPostgres ?? createPostgres2();
   const router = createRouter();
   if (!basename.startsWith("/")) {
     throw new Error(`Option 'basename' must start with a slash /`);
   }
-  const unknownTableRow = type(
-    "Record<string, string | number | boolean | null>"
-  );
+  const clientBasename = normalizeBasename(basename);
+  const unknownTableRow = type("Record<string, unknown>");
   router.get("/api/tables", {}, async () => {
-    const { databaseName, tables } = await readTables();
+    const { databaseName, tables } = await readTables(
+      postgres.connectionString
+    );
+    const tableCounts = await Promise.all(
+      tables.map(async (table) => {
+        return [
+          table,
+          await postgres.get(sql2`SELECT COUNT(*) FROM ${qualifiedTable(table)}`).then((r) => +r.count)
+        ];
+      })
+    );
     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)
-          ];
-        })
-      )
+      tableCounts.flatMap(([table, count]) => [
+        [table.tableId, count],
+        ...table.schemaName === "public" ? [[table.tableName, count]] : []
+      ])
     );
     return {
       databaseName,
@@ -258,19 +333,19 @@ function createAdminRouter({
     };
   });
   router.get("/api/tables/:table/suggestions/:column", {}, async (req) => {
-    const table = stripIdentifier(req.params.table);
-    const definition = await getTable(table);
-    const column = stripIdentifier(req.params.column);
+    const table = req.params.table;
+    const definition = await getTable(table, postgres.connectionString);
+    const column = req.params.column;
     if (!definition.columnNames.includes(column)) {
       throw BadRequest(
         `Invalid column ${column}. Must be one of: ${definition.columnNames.join(", ")}`
       );
     }
-    const statement = sql`
-        SELECT DISTINCT ${sql.identifier(column)}, *
-        FROM ${sql.identifier(table)}
-        LIMIT 500
+    const statement = sql2`
+        SELECT *
+        FROM ${qualifiedTable(definition)}
       `;
+    statement.append(sql2` ORDER BY ${sql2.identifier(column)} LIMIT 500`);
     return postgres.all(statement);
   });
   router.get(
@@ -284,12 +359,18 @@ function createAdminRouter({
       })
     },
     async (req) => {
-      const table = stripIdentifier(req.params.table);
+      const table = 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);
+      if (limit < 1 || limit > 500) {
+        throw BadRequest("Limit must be between 1 and 500");
+      }
+      if (page < 1) {
+        throw BadRequest("Page must be 1 or greater");
+      }
+      const definition = await getTable(table, postgres.connectionString);
       const orderBy = orders.map((order) => parseOrderBy(order)).filter((x) => x != null);
       const allowedColumnNames = definition.columnNames.concat(
         definition.relatedColumnNames
@@ -299,13 +380,15 @@ function createAdminRouter({
           `Invalid order value ${orderBy.map((x) => x.column).join(", ")}. Must be one of: ${allowedColumnNames.join(", ")}`
         );
       }
-      const fieldsToSelect = [sql`${sql.identifier(table)}.*`];
+      const fieldsToSelect = [sql2`${sql2.identifier("__source")}.*`];
       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)])
+            return metadata.foreignKeys.map((x) => x.tableId);
+          }).map(
+            async (t) => [t, await getTable(t, postgres.connectionString)]
+          )
         )
       );
       const aliasCounter = counter();
@@ -313,7 +396,7 @@ function createAdminRouter({
       for (const column of definition.columnNames) {
         const metadata = definition.columnMetadata[column];
         for (const {
-          table: fkTable,
+          tableId: fkTable,
           column: fkColumn
         } of metadata.foreignKeys) {
           const alias = `${fkTable}_${aliasCounter.get(fkTable)}`;
@@ -321,79 +404,89 @@ function createAdminRouter({
           const prefix = column.replace(/_id$/, "");
           for (const foreignColumn of foreignColumns) {
             fieldsToSelect.push(
-              sql`${sql.identifier(alias)}.${sql.identifier(foreignColumn)} AS ${sql.identifier(`${prefix}__${foreignColumn}`)}`
+              sql2`${sql2.identifier(alias)}.${sql2.identifier(foreignColumn)} AS ${sql2.identifier(`${prefix}__${foreignColumn}`)}`
             );
           }
           joins.push(
-            sql`
-              LEFT JOIN ${sql.identifier(fkTable)} ${sql.identifier(alias)}
-              ON ${sql.identifier(alias)}.${sql.identifier(fkColumn)} = ${sql.identifier(table)}.${sql.identifier(column)}`
+            sql2`
+              LEFT JOIN ${qualifiedTable(foreignTables[fkTable])} ${sql2.identifier(alias)}
+              ON ${sql2.identifier(alias)}.${sql2.identifier(fkColumn)} = ${sql2.identifier("__source")}.${sql2.identifier(column)}`
           );
         }
       }
-      const statement = sql`
+      const statement = sql2`
         SELECT ${joinStatements(fieldsToSelect, ", ")}
-        FROM ${sql.identifier(table)} ${joinStatements(joins, " ")}
+        FROM ${qualifiedTable(definition)} ${sql2.identifier("__source")} ${joinStatements(joins, " ")}
       `;
       if (search && search.length > 2) {
         statement.append(" WHERE ");
         statement.append(
           joinStatements(
             definition.columnNames.map(
-              (c) => sql`${sql.identifier(table)}.${sql.identifier(c)}::text ILIKE ${`%${search}%`}`
+              (c) => sql2`${sql2.identifier("__source")}.${sql2.identifier(c)}::text ILIKE ${`%${search}%`}`
             ),
             " OR "
           )
         );
       }
       if (orderBy.length > 0) {
-        statement.append(sql` ORDER BY `);
+        statement.append(sql2` ORDER BY `);
         statement.append(
           joinStatements(
-            orderBy.map(
-              (o) => sql`${sql.identifier(table)}.${sql.identifier(o.column)} ${sql.raw(o.direction)}`
-            ),
+            orderBy.map((o) => {
+              const column = definition.columnNames.includes(o.column) ? sql2`${sql2.identifier("__source")}.${sql2.identifier(o.column)}` : sql2`${sql2.identifier(o.column)}`;
+              return sql2`${column} ${sql2.raw(o.direction)}`;
+            }),
             ", "
           )
         );
       } else if (definition.primaryKey) {
         statement.append(
-          sql` ORDER BY ${sql.identifier(table)}.${sql.identifier(definition.primaryKey)}`
+          sql2` ORDER BY ${sql2.identifier("__source")}.${sql2.identifier(definition.primaryKey)}`
         );
       }
-      statement.append(sql` LIMIT ${limit} OFFSET ${limit * (page - 1)}`);
+      statement.append(sql2` LIMIT ${limit} OFFSET ${limit * (page - 1)}`);
       return await postgres.all(statement);
     }
   );
   router.get("/api/tables/:table/:pk", {}, async (req) => {
-    const table = stripIdentifier(req.params.table);
-    const definition = await getTable(table);
+    const table = req.params.table;
+    const definition = await getTable(table, postgres.connectionString);
     const primaryKey = definition.primaryKey;
     if (!primaryKey) {
       throw BadRequest(`Table ${table} has no primary key`);
     }
-    const statement = sql`
+    const statement = sql2`
         SELECT *
-        FROM ${sql.identifier(table)}
-        WHERE ${sql.identifier(primaryKey)} = ${req.params.pk}
+        FROM ${qualifiedTable(definition)}
+        WHERE ${sql2.identifier(primaryKey)} = ${req.params.pk}
       `;
-    return postgres.first(statement);
+    return postgres.get(statement);
   });
   router.post(
     "/api/tables/:table",
     { request: unknownTableRow },
     async (req) => {
-      const table = stripIdentifier(req.params.table);
-      const definition = await getTable(table);
+      const table = req.params.table;
+      const definition = await getTable(table, postgres.connectionString);
       const primaryKey = definition.primaryKey;
-      if (!primaryKey) {
-        throw BadRequest(`Table ${table} has no primary key`);
+      const data = { ...req.body };
+      for (const column of definition.columnNames) {
+        const metadata = definition.columnMetadata[column];
+        if (metadata.isGenerated || metadata.isIdentity) {
+          delete data[column];
+        }
       }
-      const { [primaryKey]: pk, ...data } = req.body;
-      const statement = sql`
-        INSERT INTO ${sql.identifier(table)}
-        ${sql.spreadInsert(data)}
-      `;
+      if (primaryKey && (data[primaryKey] == null || data[primaryKey] === "")) {
+        delete data[primaryKey];
+      }
+      const invalidColumns = Object.keys(data).filter(
+        (column) => !definition.columnNames.includes(column)
+      );
+      if (invalidColumns.length > 0) {
+        throw BadRequest(`Invalid columns: ${invalidColumns.join(", ")}`);
+      }
+      const statement = Object.keys(data).length > 0 ? sql2`INSERT INTO ${qualifiedTable(definition)} ${sql2.spreadInsert(data)} RETURNING *` : sql2`INSERT INTO ${qualifiedTable(definition)} DEFAULT VALUES RETURNING *`;
       return postgres.first(statement);
     }
   );
@@ -401,48 +494,64 @@ function createAdminRouter({
     "/api/tables/:table/:pk",
     { request: unknownTableRow },
     async (req) => {
-      const table = stripIdentifier(req.params.table);
+      const table = req.params.table;
       const pk = req.params.pk;
-      const definition = await getTable(table);
+      const definition = await getTable(table, postgres.connectionString);
       const primaryKey = definition.primaryKey;
       if (!primaryKey) {
         throw BadRequest(`Table ${table} has no primary key`);
       }
       const updatedAtColumns = definition.columnNames.filter(
-        (c) => ["updated_at", "modified_time"].includes(c)
+        (column) => ["updated_at", "modified_time"].includes(column) && !definition.columnMetadata[column].isGenerated && !definition.columnMetadata[column].isIdentity
       );
       const data = {
         ...req.body
       };
+      delete data[primaryKey];
+      for (const column of definition.columnNames) {
+        const metadata = definition.columnMetadata[column];
+        if (metadata.isGenerated || metadata.isIdentity) {
+          delete data[column];
+        }
+      }
+      const invalidColumns = Object.keys(data).filter(
+        (column) => !definition.columnNames.includes(column)
+      );
+      if (invalidColumns.length > 0) {
+        throw BadRequest(`Invalid columns: ${invalidColumns.join(", ")}`);
+      }
       for (const updateAtColumn of updatedAtColumns) {
-        data[updateAtColumn] = sql.raw("NOW()");
+        data[updateAtColumn] = sql2.raw("NOW()");
+      }
+      if (Object.keys(data).length === 0) {
+        throw BadRequest("No values to update");
       }
       return await postgres.transaction(async () => {
-        await postgres.get(sql`
-          SELECT * FROM ${sql.identifier(table)}
-          WHERE ${sql.identifier(primaryKey)} = ${req.params.pk}
+        await postgres.get(sql2`
+          SELECT * FROM ${qualifiedTable(definition)}
+          WHERE ${sql2.identifier(primaryKey)} = ${req.params.pk}
           FOR UPDATE
         `);
-        return postgres.get(sql`
-          UPDATE ${sql.identifier(table)}
-          SET ${sql.spreadUpdate(data)}
-          WHERE ${sql.identifier(primaryKey)} = ${pk}
+        return postgres.get(sql2`
+          UPDATE ${qualifiedTable(definition)}
+          SET ${sql2.spreadUpdate(data)}
+          WHERE ${sql2.identifier(primaryKey)} = ${pk}
           RETURNING *
         `);
       });
     }
   );
   router.delete("/api/tables/:table/:pk", {}, async (req) => {
-    const table = stripIdentifier(req.params.table);
-    const pk = parseInt(req.params.pk);
-    const definition = await getTable(table);
+    const table = req.params.table;
+    const pk = req.params.pk;
+    const definition = await getTable(table, postgres.connectionString);
     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}
+    const statement = sql2`
+        DELETE FROM ${qualifiedTable(definition)}
+        WHERE ${sql2.identifier(primaryKey)} = ${pk}
       `;
     await postgres.query(statement);
     return 204;
@@ -454,7 +563,8 @@ function createAdminRouter({
   );
   router.get("*", {}, async (req, res) => {
     const content = await fs.readFile(indexHtml, "utf-8");
-    return content.replace(/{{ csrf_token }}/g, generateCsrfToken(req, res)).replace(/{{ basename }}/g, basename.slice(1)).replace(/{{ title }}/g, uiOptions.title ?? "Posterboi");
+    const title = escapeHtml(uiOptions.title ?? "Posterboi");
+    return content.replace(/{{ csrf_token }}/g, generateCsrfToken(req, res)).replace(/{{ basename }}/g, escapeHtml(clientBasename)).replace(/{{ title }}/g, title);
   });
   return router.getRouter();
 }

package/dist/setupTests.d.ts

@@ -0,0 +1,41 @@
+import 'dotenv/config';
+declare module '@devmoods/config' {
+    interface Config extends ConfigFromDefs<typeof appConfig> {
+    }
+}
+declare const appConfig: import("@devmoods/config").Defs<{
+    CI: boolean;
+    PORT: number;
+    PUBLIC_URL: string;
+    AUTH_TOKEN_EXPIRES: number;
+    AUTH_TEMP_TOKEN_EXPIRES: number;
+    AUTH_OTP_EXPIRES: number;
+    AUTH_OTP_MAX_ATTEMPTS: number;
+    AUTH_JWT_SECRET: string;
+    AUTH_COOKIE_SAME_SITE: string;
+    REDIS_URL: string;
+    REDIS_KEY_PREFIX: string;
+    SENTRY_DSN: string;
+    SENTRY_TRACES_SAMPLE_RATE: number;
+    SENTRY_PROFILES_SAMPLE_RATE: number;
+    SENTRY_EVENT_LOOP_THRESHOLD: number;
+    LOG_LEVEL: string;
+    LOG_SQL: boolean;
+    NODE_ENV: string;
+    CSRF_SECRET: string;
+    READINESS_PERIOD_MS: number;
+    GRACE_PERIOD_MS: number;
+    SLACK_WEBHOOK_URL: string;
+    VITE_USE_DEV_SERVER: boolean;
+    EMAIL_HOST: string;
+    EMAIL_PORT: number;
+    EMAIL_USER: string;
+    EMAIL_PASS: string;
+    EMAIL_SENDER_NAME: string;
+    EMAIL_SENDER_ADDRESS: string;
+    GOOGLE_AUTH_CLIENT_ID: string;
+    GOOGLE_AUTH_CLIENT_SECRET: string;
+    POSTGRES_URL: string;
+    POSTGRES_PRINT_SQL: boolean;
+}>;
+export {};

package/dist/setupTests.global.d.ts

@@ -0,0 +1,2 @@
+import 'dotenv/config';
+export default function setup(): Promise<() => Promise<void>>;