@constructive-io/graphql-server 2.14.8 → 2.15.0

package/middleware/gql.js

@@ -1,131 +1,126 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListOfAllDomainsOfDb = exports.ApiByNameQuery = exports.ApiQuery = void 0;
-const graphql_tag_1 = __importDefault(require("graphql-tag"));
-// DO NOT CHANGE TO domainBySubdomainAndDomain(domain: $domain, subdomain: $subdomain)
-// condition is the way to handle since it will pass in null properly
-// e.g. subdomain.domain or domain both work
-exports.ApiQuery = (0, graphql_tag_1.default) `
-  query ApiRoot($domain: String!, $subdomain: String) {
-    domains(condition: { domain: $domain, subdomain: $subdomain }) {
-      nodes {
-        api {
-          databaseId
-          dbname
-          roleName
-          anonRole
-          isPublic
-          schemaNamesFromExt: apiExtensions {
-            nodes {
-              schemaName
-            }
-          }
-          schemaNames: schemataByApiSchemaApiIdAndSchemaId {
-            nodes {
-              schemaName
-            }
-          }
-          rlsModule {
-            privateSchema {
-              schemaName
-            }
-            authenticateStrict
-            authenticate
-            currentRole
-            currentRoleId
-          }
-          database {
-            sites {
-              nodes {
-                domains {
-                  nodes {
-                    subdomain
-                    domain
-                  }
-                }
-              }
-            }
-          } # for now keep this for patches
-          apiModules {
-            nodes {
-              name
-              data
-            }
-          }
-        }
-      }
-    }
-  }
-`;
-exports.ApiByNameQuery = (0, graphql_tag_1.default) `
-  query ApiByName($name: String!, $databaseId: UUID!) {
-    api: apiByDatabaseIdAndName(name: $name, databaseId: $databaseId) {
-      databaseId
-      dbname
-      roleName
-      anonRole
-      isPublic
-      schemaNamesFromExt: apiExtensions {
-        nodes {
-          schemaName
-        }
-      }
-      schemaNames: schemataByApiSchemaApiIdAndSchemaId {
-        nodes {
-          schemaName
-        }
-      }
-      rlsModule {
-        privateSchema {
-          schemaName
-        }
-        authenticate
-        authenticateStrict
-        currentRole
-        currentRoleId
-      }
-      database {
-        sites {
-          nodes {
-            domains {
-              nodes {
-                subdomain
-                domain
-              }
-            }
-          }
-        }
-      } # for now keep this for patches
-      apiModules {
-        nodes {
-          name
-          data
-        }
-      }
+exports.buildListApis = exports.buildApiByDatabaseIdAndName = exports.buildDomainLookup = void 0;
+const query_builder_1 = require("../codegen/orm/query-builder");
+const apiSelect = {
+    databaseId: true,
+    dbname: true,
+    roleName: true,
+    anonRole: true,
+    isPublic: true,
+    domains: {
+        select: {
+            subdomain: true,
+            domain: true,
+        },
+        connection: true,
+    },
+    apiExtensions: {
+        select: { schemaName: true },
+        connection: true,
+    },
+    schemasByApiSchemaApiIdAndSchemaId: {
+        select: { schemaName: true },
+        connection: true,
+    },
+    rlsModule: {
+        select: {
+            privateSchema: { select: { schemaName: true } },
+            authenticateStrict: true,
+            authenticate: true,
+            currentRole: true,
+            currentRoleId: true,
+        },
+    },
+    database: {
+        select: {
+            sites: {
+                select: {
+                    domains: {
+                        select: { subdomain: true, domain: true },
+                        connection: true,
+                    },
+                },
+                connection: true,
+            },
+        },
+    },
+    apiModules: {
+        select: { name: true, data: true },
+        connection: true,
+    },
+};
+const domainSelect = {
+    domain: true,
+    subdomain: true,
+    api: { select: apiSelect },
+};
+const apisSelect = {
+    id: true,
+    databaseId: true,
+    name: true,
+    dbname: true,
+    roleName: true,
+    anonRole: true,
+    isPublic: true,
+    domains: {
+        select: { domain: true, subdomain: true },
+        connection: true,
+    },
+    database: {
+        select: {
+            sites: {
+                select: {
+                    domains: {
+                        select: { domain: true, subdomain: true },
+                        connection: true,
+                    },
+                },
+                connection: true,
+            },
+        },
+    },
+};
+/**
+ * Build query for domain lookup with optional subdomain
+ * This uses domains connection instead of domainBySubdomainAndDomain
+ * because we need to handle null subdomain with condition filter
+ */
+const buildDomainLookup = (vars) => {
+    const where = {
+        domain: { equalTo: vars.domain },
+    };
+    if (vars.subdomain === null || vars.subdomain === undefined) {
+        where.subdomain = { isNull: true };
     }
-  }
-`;
-exports.ListOfAllDomainsOfDb = (0, graphql_tag_1.default) `
-  query ListApisByDatabaseId {
-    apis {
-      nodes {
-        id
-        databaseId
-        name
-        dbname
-        roleName
-        anonRole
-        isPublic
-        domains {
-          nodes {
-            domain
-            subdomain
-          }
-        }
-      }
+    else {
+        where.subdomain = { equalTo: vars.subdomain };
     }
-  }
-`;
+    return (0, query_builder_1.buildFindFirstDocument)('DomainLookup', 'domains', domainSelect, { where }, 'DomainFilter');
+};
+exports.buildDomainLookup = buildDomainLookup;
+/**
+ * Build query for API lookup by database ID and name
+ * Uses the generated apiByDatabaseIdAndName custom query
+ */
+const buildApiByDatabaseIdAndName = (vars) => {
+    // Import buildCustomDocument locally to avoid circular dependency
+    const { buildCustomDocument } = require('../codegen/orm/query-builder');
+    return buildCustomDocument('query', 'ApiByDatabaseIdAndName', 'apiByDatabaseIdAndName', apiSelect, vars, [
+        { name: 'databaseId', type: 'UUID!' },
+        { name: 'name', type: 'String!' },
+    ]);
+};
+exports.buildApiByDatabaseIdAndName = buildApiByDatabaseIdAndName;
+/**
+ * Build query to list all APIs
+ */
+const buildListApis = () => {
+    // Import buildCustomDocument locally to avoid circular dependency
+    const { buildCustomDocument } = require('../codegen/orm/query-builder');
+    return buildCustomDocument('query', 'ListApisByDatabaseId', 'apis', {
+        select: apisSelect,
+        connection: true,
+    }, undefined, []);
+};
+exports.buildListApis = buildListApis;

package/middleware/graphile.js

@@ -4,28 +4,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.graphile = void 0;
+const logger_1 = require("@pgpmjs/logger");
 const graphile_cache_1 = require("graphile-cache");
 const graphile_settings_1 = require("graphile-settings");
 const pg_cache_1 = require("pg-cache");
 const postgraphile_1 = require("postgraphile");
 require("./types"); // for Request type
 const PublicKeySignature_1 = __importDefault(require("../plugins/PublicKeySignature"));
+const log = new logger_1.Logger('graphile');
+const reqLabel = (req) => req.requestId ? `[${req.requestId}]` : '[req]';
 const graphile = (opts) => {
     return async (req, res, next) => {
+        const label = reqLabel(req);
         try {
             const api = req.api;
             if (!api) {
+                log.error(`${label} Missing API info`);
                 return res.status(500).send('Missing API info');
             }
             const key = req.svc_key;
             if (!key) {
+                log.error(`${label} Missing service cache key`);
                 return res.status(500).send('Missing service cache key');
             }
             const { dbname, anonRole, roleName, schema } = api;
-            if (graphile_cache_1.graphileCache.has(key)) {
-                const { handler } = graphile_cache_1.graphileCache.get(key);
-                return handler(req, res, next);
+            const schemaLabel = schema?.join(',') || 'unknown';
+            const cached = graphile_cache_1.graphileCache.get(key);
+            if (cached) {
+                log.debug(`${label} PostGraphile cache hit key=${key} db=${dbname} schemas=${schemaLabel}`);
+                return cached.handler(req, res, next);
             }
+            log.debug(`${label} PostGraphile cache miss key=${key} db=${dbname} schemas=${schemaLabel}`);
             const options = (0, graphile_settings_1.getGraphileSettings)({
                 ...opts,
                 graphile: {
@@ -35,12 +44,14 @@ const graphile = (opts) => {
             });
             const pubkey_challenge = api.apiModules.find((mod) => mod.name === 'pubkey_challenge');
             if (pubkey_challenge && pubkey_challenge.data) {
+                log.info(`${label} Enabling PublicKeySignature plugin for ${dbname}`);
                 options.appendPlugins.push((0, PublicKeySignature_1.default)(pubkey_challenge.data));
             }
             options.appendPlugins = options.appendPlugins ?? [];
             options.appendPlugins.push(...opts.graphile.appendPlugins);
             options.pgSettings = async function pgSettings(request) {
                 const gqlReq = request;
+                const settingsLabel = reqLabel(gqlReq);
                 const context = {
                     [`jwt.claims.database_id`]: gqlReq.databaseId,
                     [`jwt.claims.ip_address`]: gqlReq.clientIp,
@@ -52,6 +63,7 @@ const graphile = (opts) => {
                     context['jwt.claims.user_agent'] = gqlReq.get('User-Agent');
                 }
                 if (gqlReq?.token?.user_id) {
+                    log.debug(`${settingsLabel} pgSettings role=${roleName} db=${gqlReq.databaseId} ip=${gqlReq.clientIp}`);
                     return {
                         role: roleName,
                         [`jwt.claims.token_id`]: gqlReq.token.id,
@@ -59,6 +71,7 @@ const graphile = (opts) => {
                         ...context,
                     };
                 }
+                log.debug(`${settingsLabel} pgSettings role=${anonRole} db=${gqlReq.databaseId} ip=${gqlReq.clientIp}`);
                 return { role: anonRole, ...context };
             };
             options.graphqlRoute = '/graphql';
@@ -71,6 +84,7 @@ const graphile = (opts) => {
                 ...options,
                 ...opts.graphile.overrideSettings,
             };
+            log.info(`${label} Building PostGraphile handler key=${key} db=${dbname} schemas=${schemaLabel} role=${roleName} anon=${anonRole}`);
             const pgPool = (0, pg_cache_1.getPgPool)({
                 ...opts.pg,
                 database: dbname,
@@ -81,9 +95,11 @@ const graphile = (opts) => {
                 pgPoolKey: dbname,
                 handler,
             });
+            log.info(`${label} Cached PostGraphile handler key=${key} db=${dbname}`);
             return handler(req, res, next);
         }
         catch (e) {
+            log.error(`${label} PostGraphile middleware error`, e);
             return res.status(500).send(e.message);
         }
     };

package/middleware/types.d.ts

@@ -27,6 +27,7 @@ declare global {
             svc_key?: string;
             clientIp?: string;
             databaseId?: string;
+            requestId?: string;
             token?: ConstructiveAPIToken;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-server",
-  "version": "2.14.8",
+  "version": "2.15.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Constructive GraphQL Server",
   "main": "index.js",
@@ -29,7 +29,9 @@
     "lint": "eslint . --fix",
     "test": "jest --passWithNoTests",
     "test:watch": "jest --watch",
-    "bucket:create": "ts-node src/scripts/create-bucket.ts"
+    "bucket:create": "ts-node src/scripts/create-bucket.ts",
+    "codegen:schema": "ts-node src/scripts/codegen-schema.ts",
+    "codegen": "npm run codegen:schema && graphql-codegen generate-orm --schema codegen/schema.graphql --output src/codegen/orm"
   },
   "keywords": [
     "server",
@@ -52,15 +54,15 @@
     "express": "^5.2.1",
     "graphile-build": "^4.14.1",
     "graphile-cache": "^1.6.14",
-    "graphile-i18n": "^0.4.7",
-    "graphile-meta-schema": "^0.5.7",
-    "graphile-plugin-connection-filter": "^2.6.7",
-    "graphile-plugin-connection-filter-postgis": "^1.3.7",
-    "graphile-plugin-fulltext-filter": "^2.3.7",
+    "graphile-i18n": "^0.4.8",
+    "graphile-meta-schema": "^0.5.8",
+    "graphile-plugin-connection-filter": "^2.6.8",
+    "graphile-plugin-connection-filter-postgis": "^1.3.8",
+    "graphile-plugin-fulltext-filter": "^2.3.8",
     "graphile-query": "^2.4.7",
-    "graphile-search-plugin": "^0.4.8",
-    "graphile-settings": "^2.12.8",
-    "graphile-simple-inflector": "^0.4.8",
+    "graphile-search-plugin": "^0.4.9",
+    "graphile-settings": "^2.12.9",
+    "graphile-simple-inflector": "^0.4.9",
     "graphile-utils": "^4.14.1",
     "graphql": "15.10.1",
     "graphql-tag": "2.12.6",
@@ -74,14 +76,16 @@
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.958.0",
+    "@constructive-io/graphql-codegen": "2.23.2",
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.6",
     "@types/graphql-upload": "^8.0.12",
     "@types/pg": "^8.16.0",
     "@types/request-ip": "^0.0.41",
+    "graphile-test": "2.13.8",
     "makage": "^0.1.10",
     "nodemon": "^3.1.10",
     "ts-node": "^10.9.2"
   },
-  "gitHead": "8ba31ce871a6fec054ee6ea5627f44d69c635828"
+  "gitHead": "eff12e839462a1d5435f04318db1f44fc141e235"
 }

package/scripts/codegen-schema.d.ts

@@ -0,0 +1 @@
+export {};

package/scripts/codegen-schema.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_env_1 = require("@constructive-io/graphql-env");
+const logger_1 = require("@pgpmjs/logger");
+const graphile_settings_1 = require("graphile-settings");
+const pg_cache_1 = require("pg-cache");
+const graphile_query_1 = require("graphile-query");
+const graphql_1 = require("graphql");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const log = new logger_1.Logger('codegen-schema');
+const getSchemaOutputPath = () => process.env.CODEGEN_SCHEMA_OUT ??
+    node_path_1.default.resolve(__dirname, '../../codegen/schema.graphql');
+(async () => {
+    try {
+        const opts = (0, graphql_env_1.getEnvOptions)();
+        const apiOpts = opts.api || {};
+        const metaSchemas = Array.isArray(apiOpts.metaSchemas)
+            ? apiOpts.metaSchemas
+            : [];
+        let schemas;
+        let usingFallback = false;
+        const dbName = process.env.CODEGEN_DATABASE || process.env.PGDATABASE || 'constructive';
+        const pgConfig = { ...opts.pg, database: dbName };
+        log.info(`Target database for codegen: ${dbName}`);
+        if (metaSchemas.length) {
+            schemas = metaSchemas;
+            log.info(`Using meta schemas: ${schemas.join(', ')}`);
+            const pool = (0, pg_cache_1.getPgPool)(pgConfig);
+            const checkResult = await pool.query(`SELECT schema_name FROM information_schema.schemata 
+         WHERE schema_name = ANY($1::text[]) 
+         ORDER BY schema_name`, [schemas]);
+            const foundSchemas = checkResult.rows.map((r) => r.schema_name);
+            const missing = schemas.filter((s) => !foundSchemas.includes(s));
+            if (missing.length > 0) {
+                log.warn(`Missing schemas: ${missing.join(', ')}. Falling back to 'public'.`);
+                schemas = ['public'];
+                usingFallback = true;
+            }
+        }
+        else {
+            schemas = ['public'];
+            log.info('No meta schemas configured, using: public');
+            usingFallback = true;
+        }
+        if (usingFallback) {
+            log.warn('Schema will be generated from public schema only. To generate full meta schema, ensure meta tables exist.');
+        }
+        const settings = (0, graphile_settings_1.getGraphileSettings)({
+            ...opts,
+            pg: pgConfig,
+            graphile: {
+                ...opts.graphile,
+                schema: schemas,
+            },
+        });
+        const pool = (0, pg_cache_1.getPgPool)(pgConfig);
+        log.debug(`Connecting to database: ${dbName}`);
+        log.debug(`Connecting to host: ${opts.pg?.host || '(default)'}`);
+        const dbInfo = await pool.query('SELECT current_database() AS current_database, current_user AS current_user');
+        log.info(`Connected to database: ${dbInfo.rows[0]?.current_database} as user: ${dbInfo.rows[0]?.current_user}`);
+        const graphqlSchema = await (0, graphile_query_1.getSchema)(pool, settings);
+        const sdl = (0, graphql_1.printSchema)(graphqlSchema);
+        const outputPath = getSchemaOutputPath();
+        await node_fs_1.promises.mkdir(node_path_1.default.dirname(outputPath), { recursive: true });
+        await node_fs_1.promises.writeFile(outputPath, sdl, 'utf8');
+        log.success(`Schema written to ${outputPath}`);
+    }
+    catch (error) {
+        log.error('Failed to write schema', error?.stack || error);
+        process.exitCode = 1;
+    }
+})();

package/server.js

@@ -8,6 +8,7 @@ const graphql_env_1 = require("@constructive-io/graphql-env");
 const logger_1 = require("@pgpmjs/logger");
 const server_utils_1 = require("@pgpmjs/server-utils");
 const url_domains_1 = require("@constructive-io/url-domains");
+const crypto_1 = require("crypto");
 const express_1 = __importDefault(require("express"));
 // @ts-ignore
 const graphql_upload_1 = __importDefault(require("graphql-upload"));
@@ -35,6 +36,25 @@ class Server {
         const app = (0, express_1.default)();
         const api = (0, api_1.createApiMiddleware)(opts);
         const authenticate = (0, auth_1.createAuthenticateMiddleware)(opts);
+        const requestLogger = (req, res, next) => {
+            const headerRequestId = req.header('x-request-id');
+            const reqId = headerRequestId || (0, crypto_1.randomUUID)();
+            const start = process.hrtime.bigint();
+            req.requestId = reqId;
+            const host = req.hostname || req.headers.host || 'unknown';
+            const ip = req.clientIp || req.ip;
+            log.debug(`[${reqId}] -> ${req.method} ${req.originalUrl} host=${host} ip=${ip}`);
+            res.on('finish', () => {
+                const durationMs = Number(process.hrtime.bigint() - start) / 1e6;
+                const apiInfo = req.api
+                    ? `db=${req.api.dbname} schemas=${req.api.schema?.join(',') || 'none'}`
+                    : 'api=unresolved';
+                const authInfo = req.token ? 'auth=token' : 'auth=anon';
+                const svcInfo = req.svc_key ? `svc=${req.svc_key}` : 'svc=unset';
+                log.debug(`[${reqId}] <- ${res.statusCode} ${req.method} ${req.originalUrl} (${durationMs.toFixed(1)} ms) ${apiInfo} ${svcInfo} ${authInfo}`);
+            });
+            next();
+        };
         // Log startup config in dev mode
         if (isDev()) {
             log.debug(`Database: ${opts.pg?.database}@${opts.pg?.host}:${opts.pg?.port}`);
@@ -57,6 +77,7 @@ class Server {
         app.use(graphql_upload_1.default.graphqlUploadExpress());
         app.use((0, url_domains_1.middleware)());
         app.use(request_ip_1.default.mw());
+        app.use(requestLogger);
         app.use(api);
         app.use(authenticate);
         app.use((0, graphile_1.graphile)(opts));

package/types.d.ts

@@ -58,8 +58,8 @@ export interface OldApiStructure {
     dbname: string;
     anonRole: string;
     roleName: string;
-    schemaNames: SchemaNodes;
-    schemaNamesFromExt: SchemaNodes;
+    schemasByApiSchemaApiIdAndSchemaId: SchemaNodes;
+    apiExtensions: SchemaNodes;
     apiModules: ApiModuleNodes;
     rlsModule?: RlsModule;
     database?: Database;