@constructive-io/graphql-server 2.19.2 → 2.19.4

package/esm/middleware/api.js

@@ -1,50 +1,21 @@
 import { getNodeEnv } from '@constructive-io/graphql-env';
 import { Logger } from '@pgpmjs/logger';
 import { svcCache } from '@pgpmjs/server-utils';
+import { parseUrl } from '@constructive-io/url-domains';
 import { getSchema, GraphileQuery } from 'graphile-query';
 import { getGraphileSettings } from 'graphile-settings';
 import { getPgPool } from 'pg-cache';
 import errorPage50x from '../errors/50x';
 import errorPage404Message from '../errors/404-message';
-import { buildApiByDatabaseIdAndName, buildDomainLookup, buildListApis, } from './gql';
+/**
+ * Normalizes API records into ApiStructure
+ */
+import { apiListSelect, apiSelect, connectionFirst, createGraphileOrm, domainSelect, normalizeApiRecord, } from './gql';
 import './types'; // for Request type
+export { normalizeApiRecord } from './gql';
 const log = new Logger('api');
 const isDev = () => getNodeEnv() === 'development';
-const transformServiceToApi = (svc) => {
-    const api = svc.data.api;
-    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) => {
-            if (site.domains?.nodes && site.domains.nodes.length) {
-                const siteUrls = site.domains.nodes.map((domain) => {
-                    const hostname = domain.subdomain
-                        ? `${domain.subdomain}.${domain.domain}`
-                        : domain.domain;
-                    const protocol = domain.domain === 'localhost' ? 'http://' : 'https://';
-                    return protocol + hostname;
-                });
-                return [...acc, ...siteUrls];
-            }
-            return acc;
-        }, []);
-    }
-    return {
-        dbname: api.dbname,
-        anonRole: api.anonRole,
-        roleName: api.roleName,
-        schema: [...schemaNames, ...additionalSchemas],
-        apiModules: api.apiModules?.nodes?.map((node) => ({
-            name: node.name,
-            data: node.data,
-        })) || [],
-        rlsModule: api.rlsModule,
-        domains,
-        databaseId: api.databaseId,
-        isPublic: api.isPublic,
-    };
-};
+const isApiError = (svc) => !!svc && typeof svc.errorHtml === 'string';
 const getPortFromRequest = (req) => {
     const host = req.headers.host;
     if (!host)
@@ -52,6 +23,18 @@ const getPortFromRequest = (req) => {
     const parts = host.split(':');
     return parts.length === 2 ? `:${parts[1]}` : null;
 };
+const parseCommaSeparatedHeader = (value) => value
+    .split(',')
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+const getUrlDomains = (req) => {
+    const fullUrl = `${req.protocol}://${req.get('host')}${req.originalUrl}`;
+    const parsed = parseUrl(fullUrl);
+    return {
+        domain: parsed.domain ?? '',
+        subdomains: parsed.subdomains ?? [],
+    };
+};
 export const getSubdomain = (reqDomains) => {
     const names = reqDomains.filter((name) => !['www'].includes(name));
     return !names.length ? null : names.join('.');
@@ -59,9 +42,9 @@ export const getSubdomain = (reqDomains) => {
 export const createApiMiddleware = (opts) => {
     return async (req, res, next) => {
         if (opts.api?.enableServicesApi === false) {
-            const schemas = opts.api.exposedSchemas;
-            const anonRole = opts.api.anonRole;
-            const roleName = opts.api.roleName;
+            const schemas = opts.api.exposedSchemas ?? [];
+            const anonRole = opts.api.anonRole ?? '';
+            const roleName = opts.api.roleName ?? '';
             const databaseId = opts.api.defaultDatabaseId;
             const api = {
                 dbname: opts.pg?.database ?? '',
@@ -79,133 +62,101 @@ export const createApiMiddleware = (opts) => {
             return next();
         }
         try {
-            const svc = await getApiConfig(opts, req);
-            if (svc?.errorHtml) {
+            const apiConfig = await getApiConfig(opts, req);
+            if (isApiError(apiConfig)) {
                 res
                     .status(404)
-                    .send(errorPage404Message('API not found', svc.errorHtml));
+                    .send(errorPage404Message('API not found', apiConfig.errorHtml));
                 return;
             }
-            else if (!svc) {
+            else if (!apiConfig) {
                 res
                     .status(404)
                     .send(errorPage404Message('API service not found for the given domain/subdomain.'));
                 return;
             }
-            const api = transformServiceToApi(svc);
-            req.api = api;
-            req.databaseId = api.databaseId;
+            req.api = apiConfig;
+            req.databaseId = apiConfig.databaseId;
             if (isDev())
-                log.debug(`Resolved API: db=${api.dbname}, schemas=[${api.schema?.join(', ')}]`);
+                log.debug(`Resolved API: db=${apiConfig.dbname}, schemas=[${apiConfig.schema?.join(', ')}]`);
             next();
         }
-        catch (e) {
-            if (e.code === 'NO_VALID_SCHEMAS') {
-                res.status(404).send(errorPage404Message(e.message));
+        catch (error) {
+            const err = error;
+            if (err.code === 'NO_VALID_SCHEMAS') {
+                res.status(404).send(errorPage404Message(err.message));
             }
-            else if (e.message.match(/does not exist/)) {
+            else if (err.message?.match(/does not exist/)) {
                 res
                     .status(404)
                     .send(errorPage404Message("The resource you're looking for does not exist."));
             }
             else {
-                log.error('API middleware error:', e);
+                log.error('API middleware error:', err);
                 res.status(500).send(errorPage50x);
             }
         }
     };
 };
-const getHardCodedSchemata = ({ opts, schemata, databaseId, key, }) => {
-    const svc = {
-        data: {
-            api: {
-                databaseId,
-                isPublic: false,
-                dbname: opts.pg.database,
-                anonRole: 'administrator',
-                roleName: 'administrator',
-                schemaNamesFromExt: {
-                    nodes: schemata
-                        .split(',')
-                        .map((schema) => schema.trim())
-                        .map((schemaName) => ({ schemaName })),
-                },
-                schemaNames: { nodes: [] },
-                apiModules: [],
-            },
-        },
+const createAdminApiStructure = ({ opts, schemata, key, databaseId, }) => {
+    const api = {
+        dbname: opts.pg?.database ?? '',
+        anonRole: 'administrator',
+        roleName: 'administrator',
+        schema: schemata,
+        apiModules: [],
+        domains: [],
+        databaseId,
+        isPublic: false,
     };
-    svcCache.set(key, svc);
-    return svc;
+    svcCache.set(key, api);
+    return api;
 };
-const getMetaSchema = ({ opts, key, databaseId, }) => {
-    const apiOpts = opts.api || {};
-    const schemata = apiOpts.metaSchemas || [];
-    const svc = {
-        data: {
-            api: {
-                databaseId,
-                isPublic: false,
-                dbname: opts.pg.database,
-                anonRole: 'administrator',
-                roleName: 'administrator',
-                schemaNamesFromExt: {
-                    nodes: schemata.map((schemaName) => ({ schemaName })),
-                },
-                schemaNames: { nodes: [] },
-                apiModules: [],
-            },
-        },
+const queryServiceByDomainAndSubdomain = async ({ opts, key, domainModel, domain, subdomain, }) => {
+    const where = {
+        domain: { equalTo: domain },
+        subdomain: subdomain === null || subdomain === undefined
+            ? { isNull: true }
+            : { equalTo: subdomain },
     };
-    svcCache.set(key, svc);
-    return svc;
-};
-const queryServiceByDomainAndSubdomain = async ({ opts, key, client, domain, subdomain, }) => {
-    const doc = buildDomainLookup({ domain, subdomain });
-    const result = await client.query({
-        role: 'administrator',
-        query: doc.document,
-        variables: doc.variables,
-    });
-    if (result.errors?.length) {
+    const result = await domainModel
+        .findFirst({ select: domainSelect, where })
+        .execute();
+    if (!result.ok) {
         log.error('GraphQL query errors:', result.errors);
         return null;
     }
-    const nodes = result?.data?.domains?.nodes;
-    if (nodes?.length) {
-        const data = nodes[0];
-        const apiPublic = opts.api?.isPublic;
-        if (!data.api || data.api.isPublic !== apiPublic)
-            return null;
-        const svc = { data };
-        svcCache.set(key, svc);
-        return svc;
-    }
-    return null;
+    const domainRecord = result.data.domains.nodes[0];
+    const api = domainRecord?.api;
+    const apiPublic = opts.api?.isPublic;
+    if (!api || api.isPublic !== apiPublic)
+        return null;
+    const apiStructure = normalizeApiRecord(api);
+    svcCache.set(key, apiStructure);
+    return apiStructure;
 };
-const queryServiceByApiName = async ({ opts, key, client, databaseId, name, }) => {
-    const doc = buildApiByDatabaseIdAndName({ databaseId, name });
-    const result = await client.query({
-        role: 'administrator',
-        query: doc.document,
-        variables: doc.variables,
-    });
-    if (result.errors?.length) {
+export const queryServiceByApiName = async ({ opts, key, queryOps, databaseId, name, }) => {
+    if (!databaseId)
+        return null;
+    const result = await queryOps
+        .apiByDatabaseIdAndName({ databaseId, name }, { select: apiSelect })
+        .execute();
+    if (!result.ok) {
         log.error('GraphQL query errors:', result.errors);
         return null;
     }
-    const data = result?.data;
+    const api = result.data.apiByDatabaseIdAndName;
     const apiPublic = opts.api?.isPublic;
-    if (data?.api && data.api.isPublic === apiPublic) {
-        const svc = { data };
-        svcCache.set(key, svc);
-        return svc;
+    if (api && api.isPublic === apiPublic) {
+        const apiStructure = normalizeApiRecord(api);
+        svcCache.set(key, apiStructure);
+        return apiStructure;
     }
     return null;
 };
-const getSvcKey = (opts, req) => {
-    const domain = req.urlDomains.domain;
-    const key = req.urlDomains.subdomains
+export const getSvcKey = (opts, req) => {
+    const { domain, subdomains } = getUrlDomains(req);
+    const key = subdomains
         .filter((name) => !['www'].includes(name))
         .concat(domain)
         .join('.');
@@ -229,95 +180,118 @@ const validateSchemata = async (pool, schemata) => {
 };
 export const getApiConfig = async (opts, req) => {
     const rootPgPool = getPgPool(opts.pg);
-    // @ts-ignore
-    const subdomain = getSubdomain(req.urlDomains.subdomains);
-    const domain = req.urlDomains.domain;
+    const { domain, subdomains } = getUrlDomains(req);
+    const subdomain = getSubdomain(subdomains);
     const key = getSvcKey(opts, req);
     req.svc_key = key;
-    let svc;
+    let apiConfig;
     if (svcCache.has(key)) {
         if (isDev())
             log.debug(`Cache HIT for key=${key}`);
-        svc = svcCache.get(key);
+        apiConfig = svcCache.get(key);
     }
     else {
         if (isDev())
             log.debug(`Cache MISS for key=${key}, looking up API`);
         const apiOpts = opts.api || {};
-        const allSchemata = apiOpts.metaSchemas || [];
-        const validatedSchemata = await validateSchemata(rootPgPool, allSchemata);
+        const apiPublic = apiOpts.isPublic;
+        const schemataHeader = req.get('X-Schemata');
+        const apiNameHeader = req.get('X-Api-Name');
+        const metaSchemaHeader = req.get('X-Meta-Schema');
+        const databaseIdHeader = req.get('X-Database-Id');
+        const headerSchemata = schemataHeader
+            ? parseCommaSeparatedHeader(schemataHeader)
+            : [];
+        const candidateSchemata = apiPublic === false && headerSchemata.length
+            ? Array.from(new Set([...(apiOpts.metaSchemas || []), ...headerSchemata]))
+            : apiOpts.metaSchemas || [];
+        const validatedSchemata = await validateSchemata(rootPgPool, candidateSchemata);
         if (validatedSchemata.length === 0) {
-            const apiOpts2 = opts.api || {};
-            const message = `No valid schemas found. Configured metaSchemas: [${(apiOpts2.metaSchemas || []).join(', ')}]`;
+            const schemaSource = headerSchemata.length
+                ? headerSchemata
+                : apiOpts.metaSchemas || [];
+            const label = headerSchemata.length ? 'X-Schemata' : 'metaSchemas';
+            const message = `No valid schemas found. Configured ${label}: [${schemaSource.join(', ')}]`;
             if (isDev())
                 log.debug(message);
             const error = new Error(message);
             error.code = 'NO_VALID_SCHEMAS';
             throw error;
         }
+        const validSchemaSet = new Set(validatedSchemata);
+        const validatedHeaderSchemata = headerSchemata.filter((schemaName) => validSchemaSet.has(schemaName));
         const settings = getGraphileSettings({
             graphile: {
                 schema: validatedSchemata,
             },
         });
-        // @ts-ignore
-        const schema = await getSchema(rootPgPool, settings);
-        // @ts-ignore
-        const client = new GraphileQuery({ schema, pool: rootPgPool, settings });
-        const apiPublic = opts.api?.isPublic;
+        const graphileSettings = {
+            ...settings,
+            schema: validatedSchemata,
+        };
+        const schema = await getSchema(rootPgPool, graphileSettings);
+        const graphileClient = new GraphileQuery({
+            schema,
+            pool: rootPgPool,
+            settings: graphileSettings,
+        });
+        const orm = createGraphileOrm(graphileClient);
         if (apiPublic === false) {
-            if (req.get('X-Schemata')) {
-                svc = getHardCodedSchemata({
+            if (schemataHeader) {
+                if (validatedHeaderSchemata.length === 0) {
+                    return {
+                        errorHtml: 'No valid schemas found for the supplied X-Schemata header.',
+                    };
+                }
+                apiConfig = createAdminApiStructure({
                     opts,
+                    schemata: validatedHeaderSchemata,
                     key,
-                    schemata: req.get('X-Schemata'),
-                    databaseId: req.get('X-Database-Id'),
+                    databaseId: databaseIdHeader,
                 });
             }
-            else if (req.get('X-Api-Name')) {
-                svc = await queryServiceByApiName({
+            else if (apiNameHeader) {
+                apiConfig = await queryServiceByApiName({
                     opts,
                     key,
-                    client,
-                    name: req.get('X-Api-Name'),
-                    databaseId: req.get('X-Database-Id'),
+                    queryOps: orm.query,
+                    name: apiNameHeader,
+                    databaseId: databaseIdHeader,
                 });
             }
-            else if (req.get('X-Meta-Schema')) {
-                svc = getMetaSchema({
+            else if (metaSchemaHeader) {
+                apiConfig = createAdminApiStructure({
                     opts,
+                    schemata: validatedSchemata,
                     key,
-                    databaseId: req.get('X-Database-Id'),
+                    databaseId: databaseIdHeader,
                 });
             }
             else {
-                svc = await queryServiceByDomainAndSubdomain({
+                apiConfig = await queryServiceByDomainAndSubdomain({
                     opts,
                     key,
-                    client,
+                    domainModel: orm.domain,
                     domain,
                     subdomain,
                 });
             }
         }
         else {
-            svc = await queryServiceByDomainAndSubdomain({
+            apiConfig = await queryServiceByDomainAndSubdomain({
                 opts,
                 key,
-                client,
+                domainModel: orm.domain,
                 domain,
                 subdomain,
             });
-            if (!svc) {
+            if (!apiConfig) {
+                // IMPORTANT NOTE: ONLY DO THIS IN DEV MODE
                 if (getNodeEnv() === 'development') {
-                    // TODO ONLY DO THIS IN DEV MODE
-                    const fallbackResult = await client.query({
-                        role: 'administrator',
-                        // @ts-ignore
-                        query: buildListApis().document,
-                    });
-                    if (!fallbackResult.errors?.length &&
-                        fallbackResult.data?.apis?.nodes?.length) {
+                    const fallbackResult = await orm.api
+                        .findMany({ select: apiListSelect, first: connectionFirst })
+                        .execute();
+                    if (fallbackResult.ok && fallbackResult.data.apis.nodes.length) {
                         const port = getPortFromRequest(req);
                         const allDomains = fallbackResult.data.apis.nodes.flatMap((api) => api.domains.nodes.map((d) => ({
                             domain: d.domain,
@@ -329,7 +303,7 @@ export const getApiConfig = async (opts, req) => {
                         const linksHtml = allDomains.length
                             ? `<ul class="mt-4 pl-5 list-disc space-y-1">` +
                                 allDomains
-                                    .map((d) => `<li><a href="${d.href}" class="text-brand hover:underline">${d.href}</a></li>`)
+                                    .map((domainLink) => `<li><a href="${domainLink.href}" class="text-brand hover:underline">${domainLink.href}</a></li>`)
                                     .join('') +
                                 `</ul>`
                             : `<p class="text-gray-600">No APIs are currently registered for this database.</p>`;
@@ -339,13 +313,11 @@ export const getApiConfig = async (opts, req) => {
             ${linksHtml}
           </div>
         `.trim();
-                        return {
-                            errorHtml,
-                        };
+                        return { errorHtml };
                     }
                 }
             }
         }
     }
-    return svc;
+    return apiConfig;
 };

package/esm/middleware/gql.js

@@ -1,5 +1,8 @@
-import { buildFindFirstDocument } from '../codegen/orm/query-builder';
-const apiSelect = {
+import { OrmClient, } from '../codegen/orm/client';
+import { ApiModel, DomainModel } from '../codegen/orm/models';
+import { createQueryOperations } from '../codegen/orm/query';
+export const connectionFirst = 1000;
+export const apiSelect = {
     databaseId: true,
     dbname: true,
     roleName: true,
@@ -10,15 +13,15 @@ const apiSelect = {
             subdomain: true,
             domain: true,
         },
-        connection: true,
+        first: connectionFirst,
     },
     apiExtensions: {
         select: { schemaName: true },
-        connection: true,
+        first: connectionFirst,
     },
     schemasByApiSchemaApiIdAndSchemaId: {
         select: { schemaName: true },
-        connection: true,
+        first: connectionFirst,
     },
     rlsModule: {
         select: {
@@ -29,30 +32,17 @@ const apiSelect = {
             currentRoleId: true,
         },
     },
-    database: {
-        select: {
-            sites: {
-                select: {
-                    domains: {
-                        select: { subdomain: true, domain: true },
-                        connection: true,
-                    },
-                },
-                connection: true,
-            },
-        },
-    },
     apiModules: {
         select: { name: true, data: true },
-        connection: true,
+        first: connectionFirst,
     },
 };
-const domainSelect = {
+export const domainSelect = {
     domain: true,
     subdomain: true,
     api: { select: apiSelect },
 };
-const apisSelect = {
+export const apiListSelect = {
     id: true,
     databaseId: true,
     name: true,
@@ -62,59 +52,70 @@ const apisSelect = {
     isPublic: true,
     domains: {
         select: { domain: true, subdomain: true },
-        connection: true,
-    },
-    database: {
-        select: {
-            sites: {
-                select: {
-                    domains: {
-                        select: { domain: true, subdomain: true },
-                        connection: true,
-                    },
-                },
-                connection: true,
-            },
-        },
+        first: connectionFirst,
     },
 };
-/**
- * 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 };
+class GraphileOrmClient extends OrmClient {
+    graphile;
+    constructor(graphile) {
+        super({ endpoint: 'http://localhost/graphql' });
+        this.graphile = graphile;
     }
-    else {
-        where.subdomain = { equalTo: vars.subdomain };
+    async execute(document, variables) {
+        const result = await this.graphile.query({
+            role: 'administrator',
+            query: document,
+            variables,
+        });
+        if (result.errors?.length) {
+            return {
+                ok: false,
+                data: null,
+                errors: result.errors,
+            };
+        }
+        return {
+            ok: true,
+            data: result.data,
+            errors: undefined,
+        };
     }
-    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!' },
-    ]);
+}
+export const createGraphileOrm = (graphile) => {
+    const client = new GraphileOrmClient(graphile);
+    return {
+        api: new ApiModel(client),
+        domain: new DomainModel(client),
+        query: createQueryOperations(client),
+    };
 };
-/**
- * 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, []);
+export const normalizeApiRecord = (api) => {
+    const schemaNames = (api.apiExtensions?.nodes ?? []).flatMap((node) => node.schemaName ? [node.schemaName] : []);
+    const additionalSchemas = (api.schemasByApiSchemaApiIdAndSchemaId?.nodes ?? []).flatMap((node) => (node.schemaName ? [node.schemaName] : []));
+    let domains = [];
+    if (api.domains?.nodes?.length) {
+        domains = api.domains.nodes.reduce((acc, domain) => {
+            if (!domain.domain)
+                return acc;
+            const hostname = domain.subdomain
+                ? `${domain.subdomain}.${domain.domain}`
+                : domain.domain;
+            const protocol = domain.domain === 'localhost' ? 'http://' : 'https://';
+            return [...acc, protocol + hostname];
+        }, []);
+    }
+    return {
+        dbname: api.dbname,
+        anonRole: api.anonRole,
+        roleName: api.roleName,
+        schema: [...schemaNames, ...additionalSchemas],
+        apiModules: api.apiModules?.nodes?.map((node) => ({
+            name: node.name,
+            data: node.data,
+        })) || [],
+        rlsModule: api.rlsModule,
+        domains,
+        databaseId: api.databaseId,
+        isPublic: api.isPublic,
+    };
 };

package/middleware/api.d.ts

@@ -1,6 +1,19 @@
-import { PgpmOptions } from '@pgpmjs/types';
 import { NextFunction, Request, Response } from 'express';
+/**
+ * Normalizes API records into ApiStructure
+ */
+import { type ApiQueryOps } from './gql';
+import { ApiConfigResult, ApiOptions, ApiStructure } from '../types';
 import './types';
+export { normalizeApiRecord } from './gql';
 export declare const getSubdomain: (reqDomains: string[]) => string | null;
-export declare const createApiMiddleware: (opts: any) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
-export declare const getApiConfig: (opts: PgpmOptions, req: Request) => Promise<any>;
+export declare const createApiMiddleware: (opts: ApiOptions) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export declare const queryServiceByApiName: ({ opts, key, queryOps, databaseId, name, }: {
+    opts: ApiOptions;
+    key: string;
+    queryOps: ApiQueryOps;
+    databaseId?: string;
+    name: string;
+}) => Promise<ApiStructure | null>;
+export declare const getSvcKey: (opts: ApiOptions, req: Request) => string;
+export declare const getApiConfig: (opts: ApiOptions, req: Request) => Promise<ApiConfigResult>;