@constructive-io/graphql-server 2.14.8 → 2.15.0

package/esm/middleware/gql.js

@@ -1,125 +1,120 @@
-import gql from '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
-export const ApiQuery = gql `
-  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
-            }
-          }
-        }
-      }
+import { buildFindFirstDocument } from '../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
+ */
+export const buildDomainLookup = (vars) => {
+    const where = {
+        domain: { equalTo: vars.domain },
+    };
+    if (vars.subdomain === null || vars.subdomain === undefined) {
+        where.subdomain = { isNull: true };
     }
-  }
-`;
-export const ApiByNameQuery = gql `
-  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
-        }
-      }
+    else {
+        where.subdomain = { equalTo: vars.subdomain };
     }
-  }
-`;
-export const ListOfAllDomainsOfDb = gql `
-  query ListApisByDatabaseId {
-    apis {
-      nodes {
-        id
-        databaseId
-        name
-        dbname
-        roleName
-        anonRole
-        isPublic
-        domains {
-          nodes {
-            domain
-            subdomain
-          }
-        }
-      }
-    }
-  }
-`;
+    return buildFindFirstDocument('DomainLookup', 'domains', domainSelect, { where }, 'DomainFilter');
+};
+/**
+ * Build query for API lookup by database ID and name
+ * Uses the generated apiByDatabaseIdAndName custom query
+ */
+export 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!' },
+    ]);
+};
+/**
+ * Build query to list all APIs
+ */
+export 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, []);
+};

package/esm/middleware/graphile.js

@@ -1,25 +1,34 @@
+import { Logger } from '@pgpmjs/logger';
 import { graphileCache } from 'graphile-cache';
 import { getGraphileSettings as getSettings } from 'graphile-settings';
 import { getPgPool } from 'pg-cache';
 import { postgraphile } from 'postgraphile';
 import './types'; // for Request type
 import PublicKeySignature from '../plugins/PublicKeySignature';
+const log = new Logger('graphile');
+const reqLabel = (req) => req.requestId ? `[${req.requestId}]` : '[req]';
 export 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 (graphileCache.has(key)) {
-                const { handler } = graphileCache.get(key);
-                return handler(req, res, next);
+            const schemaLabel = schema?.join(',') || 'unknown';
+            const cached = 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 = getSettings({
                 ...opts,
                 graphile: {
@@ -29,12 +38,14 @@ export 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(PublicKeySignature(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,
@@ -46,6 +57,7 @@ export 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,
@@ -53,6 +65,7 @@ export const graphile = (opts) => {
                         ...context,
                     };
                 }
+                log.debug(`${settingsLabel} pgSettings role=${anonRole} db=${gqlReq.databaseId} ip=${gqlReq.clientIp}`);
                 return { role: anonRole, ...context };
             };
             options.graphqlRoute = '/graphql';
@@ -65,6 +78,7 @@ export 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 = getPgPool({
                 ...opts.pg,
                 database: dbname,
@@ -75,9 +89,11 @@ export 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/esm/scripts/codegen-schema.js

@@ -0,0 +1,71 @@
+import { getEnvOptions } from '@constructive-io/graphql-env';
+import { Logger } from '@pgpmjs/logger';
+import { getGraphileSettings } from 'graphile-settings';
+import { getPgPool } from 'pg-cache';
+import { getSchema } from 'graphile-query';
+import { printSchema } from 'graphql';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+const log = new Logger('codegen-schema');
+const getSchemaOutputPath = () => process.env.CODEGEN_SCHEMA_OUT ??
+    path.resolve(__dirname, '../../codegen/schema.graphql');
+(async () => {
+    try {
+        const opts = 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 = 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 = getGraphileSettings({
+            ...opts,
+            pg: pgConfig,
+            graphile: {
+                ...opts.graphile,
+                schema: schemas,
+            },
+        });
+        const pool = 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 getSchema(pool, settings);
+        const sdl = printSchema(graphqlSchema);
+        const outputPath = getSchemaOutputPath();
+        await fs.mkdir(path.dirname(outputPath), { recursive: true });
+        await fs.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/esm/server.js

@@ -2,6 +2,7 @@ import { getEnvOptions, getNodeEnv } from '@constructive-io/graphql-env';
 import { Logger } from '@pgpmjs/logger';
 import { healthz, poweredBy, trustProxy } from '@pgpmjs/server-utils';
 import { middleware as parseDomains } from '@constructive-io/url-domains';
+import { randomUUID } from 'crypto';
 import express from 'express';
 // @ts-ignore
 import graphqlUpload from 'graphql-upload';
@@ -28,6 +29,25 @@ class Server {
         const app = express();
         const api = createApiMiddleware(opts);
         const authenticate = createAuthenticateMiddleware(opts);
+        const requestLogger = (req, res, next) => {
+            const headerRequestId = req.header('x-request-id');
+            const reqId = headerRequestId || 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}`);
@@ -50,6 +70,7 @@ class Server {
         app.use(graphqlUpload.graphqlUploadExpress());
         app.use(parseDomains());
         app.use(requestIp.mw());
+        app.use(requestLogger);
         app.use(api);
         app.use(authenticate);
         app.use(graphile(opts));

package/middleware/api.js

@@ -18,8 +18,8 @@ const log = new logger_1.Logger('api');
 const isDev = () => (0, graphql_env_1.getNodeEnv)() === 'development';
 const transformServiceToApi = (svc) => {
     const api = svc.data.api;
-    const schemaNames = api.schemaNamesFromExt?.nodes?.map((n) => n.schemaName) || [];
-    const additionalSchemas = api.schemaNames?.nodes?.map((n) => n.schemaName) || [];
+    const schemaNames = api.apiExtensions?.nodes?.map((n) => n.schemaName) || [];
+    const additionalSchemas = api.schemasByApiSchemaApiIdAndSchemaId?.nodes?.map((n) => n.schemaName) || [];
     let domains = [];
     if (api.database?.sites?.nodes) {
         domains = api.database.sites.nodes.reduce((acc, site) => {
@@ -169,10 +169,11 @@ const getMetaSchema = ({ opts, key, databaseId, }) => {
     return svc;
 };
 const queryServiceByDomainAndSubdomain = async ({ opts, key, client, domain, subdomain, }) => {
+    const doc = (0, gql_1.buildDomainLookup)({ domain, subdomain });
     const result = await client.query({
         role: 'administrator',
-        query: gql_1.ApiQuery,
-        variables: { domain, subdomain },
+        query: doc.document,
+        variables: doc.variables,
     });
     if (result.errors?.length) {
         log.error('GraphQL query errors:', result.errors);
@@ -191,10 +192,11 @@ const queryServiceByDomainAndSubdomain = async ({ opts, key, client, domain, sub
     return null;
 };
 const queryServiceByApiName = async ({ opts, key, client, databaseId, name, }) => {
+    const doc = (0, gql_1.buildApiByDatabaseIdAndName)({ databaseId, name });
     const result = await client.query({
         role: 'administrator',
-        query: gql_1.ApiByNameQuery,
-        variables: { databaseId, name },
+        query: doc.document,
+        variables: doc.variables,
     });
     if (result.errors?.length) {
         log.error('GraphQL query errors:', result.errors);
@@ -320,8 +322,7 @@ const getApiConfig = async (opts, req) => {
                     const fallbackResult = await client.query({
                         role: 'administrator',
                         // @ts-ignore
-                        query: gql_1.ListOfAllDomainsOfDb,
-                        // variables: { databaseId }
+                        query: (0, gql_1.buildListApis)().document,
                     });
                     if (!fallbackResult.errors?.length &&
                         fallbackResult.data?.apis?.nodes?.length) {

package/middleware/gql.d.ts

@@ -1,6 +1,26 @@
-import gql from 'graphql-tag';
-type GraphQLDocument = ReturnType<typeof gql>;
-export declare const ApiQuery: GraphQLDocument;
-export declare const ApiByNameQuery: GraphQLDocument;
-export declare const ListOfAllDomainsOfDb: GraphQLDocument;
+type BuiltDocument = {
+    document: string;
+    variables: Record<string, unknown>;
+};
+/**
+ * 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
+ */
+export declare const buildDomainLookup: (vars: {
+    domain: string;
+    subdomain?: string | null;
+}) => BuiltDocument;
+/**
+ * Build query for API lookup by database ID and name
+ * Uses the generated apiByDatabaseIdAndName custom query
+ */
+export declare const buildApiByDatabaseIdAndName: (vars: {
+    databaseId: string;
+    name: string;
+}) => BuiltDocument;
+/**
+ * Build query to list all APIs
+ */
+export declare const buildListApis: () => BuiltDocument;
 export {};