@constructive-io/graphql-server 2.14.8 → 2.15.1

package/esm/codegen/orm/query/index.js

@@ -0,0 +1,287 @@
+import { QueryBuilder, buildCustomDocument } from '../query-builder';
+// ============================================================================
+// Query Operations Factory
+// ============================================================================
+export function createQueryOperations(client) {
+    return {
+        checkConstraintByTableIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'CheckConstraintByTableIdAndName',
+            fieldName: 'checkConstraintByTableIdAndName',
+            ...buildCustomDocument('query', 'CheckConstraintByTableIdAndName', 'checkConstraintByTableIdAndName', options?.select, args, [
+                { name: 'tableId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        databaseBySchemaName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'DatabaseBySchemaName',
+            fieldName: 'databaseBySchemaName',
+            ...buildCustomDocument('query', 'DatabaseBySchemaName', 'databaseBySchemaName', options?.select, args, [{ name: 'schemaName', type: 'String!' }]),
+        }),
+        databaseByPrivateSchemaName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'DatabaseByPrivateSchemaName',
+            fieldName: 'databaseByPrivateSchemaName',
+            ...buildCustomDocument('query', 'DatabaseByPrivateSchemaName', 'databaseByPrivateSchemaName', options?.select, args, [{ name: 'privateSchemaName', type: 'String!' }]),
+        }),
+        databaseExtension: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'DatabaseExtension',
+            fieldName: 'databaseExtension',
+            ...buildCustomDocument('query', 'DatabaseExtension', 'databaseExtension', options?.select, args, [{ name: 'name', type: 'String!' }]),
+        }),
+        fieldByTableIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'FieldByTableIdAndName',
+            fieldName: 'fieldByTableIdAndName',
+            ...buildCustomDocument('query', 'FieldByTableIdAndName', 'fieldByTableIdAndName', options?.select, args, [
+                { name: 'tableId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        foreignKeyConstraintByTableIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ForeignKeyConstraintByTableIdAndName',
+            fieldName: 'foreignKeyConstraintByTableIdAndName',
+            ...buildCustomDocument('query', 'ForeignKeyConstraintByTableIdAndName', 'foreignKeyConstraintByTableIdAndName', options?.select, args, [
+                { name: 'tableId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        indexByDatabaseIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'IndexByDatabaseIdAndName',
+            fieldName: 'indexByDatabaseIdAndName',
+            ...buildCustomDocument('query', 'IndexByDatabaseIdAndName', 'indexByDatabaseIdAndName', options?.select, args, [
+                { name: 'databaseId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        limitFunctionByDatabaseIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'LimitFunctionByDatabaseIdAndName',
+            fieldName: 'limitFunctionByDatabaseIdAndName',
+            ...buildCustomDocument('query', 'LimitFunctionByDatabaseIdAndName', 'limitFunctionByDatabaseIdAndName', options?.select, args, [
+                { name: 'databaseId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        policyByTableIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'PolicyByTableIdAndName',
+            fieldName: 'policyByTableIdAndName',
+            ...buildCustomDocument('query', 'PolicyByTableIdAndName', 'policyByTableIdAndName', options?.select, args, [
+                { name: 'tableId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        primaryKeyConstraintByTableIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'PrimaryKeyConstraintByTableIdAndName',
+            fieldName: 'primaryKeyConstraintByTableIdAndName',
+            ...buildCustomDocument('query', 'PrimaryKeyConstraintByTableIdAndName', 'primaryKeyConstraintByTableIdAndName', options?.select, args, [
+                { name: 'tableId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        procedureByDatabaseIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ProcedureByDatabaseIdAndName',
+            fieldName: 'procedureByDatabaseIdAndName',
+            ...buildCustomDocument('query', 'ProcedureByDatabaseIdAndName', 'procedureByDatabaseIdAndName', options?.select, args, [
+                { name: 'databaseId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        rlsFunctionByDatabaseIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'RlsFunctionByDatabaseIdAndName',
+            fieldName: 'rlsFunctionByDatabaseIdAndName',
+            ...buildCustomDocument('query', 'RlsFunctionByDatabaseIdAndName', 'rlsFunctionByDatabaseIdAndName', options?.select, args, [
+                { name: 'databaseId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        schemaByDatabaseIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'SchemaByDatabaseIdAndName',
+            fieldName: 'schemaByDatabaseIdAndName',
+            ...buildCustomDocument('query', 'SchemaByDatabaseIdAndName', 'schemaByDatabaseIdAndName', options?.select, args, [
+                { name: 'databaseId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        schemaBySchemaName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'SchemaBySchemaName',
+            fieldName: 'schemaBySchemaName',
+            ...buildCustomDocument('query', 'SchemaBySchemaName', 'schemaBySchemaName', options?.select, args, [{ name: 'schemaName', type: 'String!' }]),
+        }),
+        tableByDatabaseIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'TableByDatabaseIdAndName',
+            fieldName: 'tableByDatabaseIdAndName',
+            ...buildCustomDocument('query', 'TableByDatabaseIdAndName', 'tableByDatabaseIdAndName', options?.select, args, [
+                { name: 'databaseId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        triggerByTableIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'TriggerByTableIdAndName',
+            fieldName: 'triggerByTableIdAndName',
+            ...buildCustomDocument('query', 'TriggerByTableIdAndName', 'triggerByTableIdAndName', options?.select, args, [
+                { name: 'tableId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        triggerFunctionByDatabaseIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'TriggerFunctionByDatabaseIdAndName',
+            fieldName: 'triggerFunctionByDatabaseIdAndName',
+            ...buildCustomDocument('query', 'TriggerFunctionByDatabaseIdAndName', 'triggerFunctionByDatabaseIdAndName', options?.select, args, [
+                { name: 'databaseId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        uniqueConstraintByTableIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'UniqueConstraintByTableIdAndName',
+            fieldName: 'uniqueConstraintByTableIdAndName',
+            ...buildCustomDocument('query', 'UniqueConstraintByTableIdAndName', 'uniqueConstraintByTableIdAndName', options?.select, args, [
+                { name: 'tableId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        apiExtensionBySchemaNameAndApiId: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ApiExtensionBySchemaNameAndApiId',
+            fieldName: 'apiExtensionBySchemaNameAndApiId',
+            ...buildCustomDocument('query', 'ApiExtensionBySchemaNameAndApiId', 'apiExtensionBySchemaNameAndApiId', options?.select, args, [
+                { name: 'schemaName', type: 'String!' },
+                { name: 'apiId', type: 'UUID!' },
+            ]),
+        }),
+        apiSchemaByApiIdAndSchemaId: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ApiSchemaByApiIdAndSchemaId',
+            fieldName: 'apiSchemaByApiIdAndSchemaId',
+            ...buildCustomDocument('query', 'ApiSchemaByApiIdAndSchemaId', 'apiSchemaByApiIdAndSchemaId', options?.select, args, [
+                { name: 'apiId', type: 'UUID!' },
+                { name: 'schemaId', type: 'UUID!' },
+            ]),
+        }),
+        apiByDatabaseIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ApiByDatabaseIdAndName',
+            fieldName: 'apiByDatabaseIdAndName',
+            ...buildCustomDocument('query', 'ApiByDatabaseIdAndName', 'apiByDatabaseIdAndName', options?.select, args, [
+                { name: 'databaseId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        appBySiteId: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'AppBySiteId',
+            fieldName: 'appBySiteId',
+            ...buildCustomDocument('query', 'AppBySiteId', 'appBySiteId', options?.select, args, [{ name: 'siteId', type: 'UUID!' }]),
+        }),
+        domainBySubdomainAndDomain: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'DomainBySubdomainAndDomain',
+            fieldName: 'domainBySubdomainAndDomain',
+            ...buildCustomDocument('query', 'DomainBySubdomainAndDomain', 'domainBySubdomainAndDomain', options?.select, args, [
+                { name: 'subdomain', type: 'String!' },
+                { name: 'domain', type: 'String!' },
+            ]),
+        }),
+        hierarchyModuleByDatabaseId: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'HierarchyModuleByDatabaseId',
+            fieldName: 'hierarchyModuleByDatabaseId',
+            ...buildCustomDocument('query', 'HierarchyModuleByDatabaseId', 'hierarchyModuleByDatabaseId', options?.select, args, [{ name: 'databaseId', type: 'UUID!' }]),
+        }),
+        moduleDefinitionByNameAndContext: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ModuleDefinitionByNameAndContext',
+            fieldName: 'moduleDefinitionByNameAndContext',
+            ...buildCustomDocument('query', 'ModuleDefinitionByNameAndContext', 'moduleDefinitionByNameAndContext', options?.select, args, [
+                { name: 'name', type: 'String!' },
+                { name: 'context', type: 'String!' },
+            ]),
+        }),
+        moduleFieldByModuleDefnIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ModuleFieldByModuleDefnIdAndName',
+            fieldName: 'moduleFieldByModuleDefnIdAndName',
+            ...buildCustomDocument('query', 'ModuleFieldByModuleDefnIdAndName', 'moduleFieldByModuleDefnIdAndName', options?.select, args, [
+                { name: 'moduleDefnId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        moduleInputRecordByModuleIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ModuleInputRecordByModuleIdAndName',
+            fieldName: 'moduleInputRecordByModuleIdAndName',
+            ...buildCustomDocument('query', 'ModuleInputRecordByModuleIdAndName', 'moduleInputRecordByModuleIdAndName', options?.select, args, [
+                { name: 'moduleId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        moduleOutputByModuleIdAndName: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ModuleOutputByModuleIdAndName',
+            fieldName: 'moduleOutputByModuleIdAndName',
+            ...buildCustomDocument('query', 'ModuleOutputByModuleIdAndName', 'moduleOutputByModuleIdAndName', options?.select, args, [
+                { name: 'moduleId', type: 'UUID!' },
+                { name: 'name', type: 'String!' },
+            ]),
+        }),
+        profilesModuleByDatabaseIdAndMembershipType: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ProfilesModuleByDatabaseIdAndMembershipType',
+            fieldName: 'profilesModuleByDatabaseIdAndMembershipType',
+            ...buildCustomDocument('query', 'ProfilesModuleByDatabaseIdAndMembershipType', 'profilesModuleByDatabaseIdAndMembershipType', options?.select, args, [
+                { name: 'databaseId', type: 'UUID!' },
+                { name: 'membershipType', type: 'Int!' },
+            ]),
+        }),
+        rlsModuleByApiId: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'RlsModuleByApiId',
+            fieldName: 'rlsModuleByApiId',
+            ...buildCustomDocument('query', 'RlsModuleByApiId', 'rlsModuleByApiId', options?.select, args, [{ name: 'apiId', type: 'UUID!' }]),
+        }),
+    };
+}

package/esm/codegen/orm/query-builder.js

@@ -0,0 +1,238 @@
+/**
+ * Query Builder - Builds and executes GraphQL operations
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { GraphQLRequestError } from './client';
+export class QueryBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Execute the query and return a discriminated union result
+     * Use result.ok to check success, or .unwrap() to throw on error
+     */
+    async execute() {
+        return this.config.client.execute(this.config.document, this.config.variables);
+    }
+    /**
+     * Execute and unwrap the result, throwing GraphQLRequestError on failure
+     * @throws {GraphQLRequestError} If the query returns errors
+     */
+    async unwrap() {
+        const result = await this.execute();
+        if (!result.ok) {
+            throw new GraphQLRequestError(result.errors, result.data);
+        }
+        return result.data;
+    }
+    /**
+     * Execute and unwrap, returning defaultValue on error instead of throwing
+     */
+    async unwrapOr(defaultValue) {
+        const result = await this.execute();
+        if (!result.ok) {
+            return defaultValue;
+        }
+        return result.data;
+    }
+    /**
+     * Execute and unwrap, calling onError callback on failure
+     */
+    async unwrapOrElse(onError) {
+        const result = await this.execute();
+        if (!result.ok) {
+            return onError(result.errors);
+        }
+        return result.data;
+    }
+    toGraphQL() {
+        return this.config.document;
+    }
+    getVariables() {
+        return this.config.variables;
+    }
+}
+// ============================================================================
+// Document Builders
+// ============================================================================
+export function buildSelections(select) {
+    if (!select)
+        return '';
+    const fields = [];
+    for (const [key, value] of Object.entries(select)) {
+        if (value === false || value === undefined)
+            continue;
+        if (value === true) {
+            fields.push(key);
+            continue;
+        }
+        if (typeof value === 'object' && value !== null) {
+            const nested = value;
+            if (nested.select) {
+                const nestedSelections = buildSelections(nested.select);
+                // Check if this is a connection type (has pagination args or explicit connection flag)
+                const isConnection = nested.connection === true ||
+                    nested.first !== undefined ||
+                    nested.filter !== undefined;
+                if (isConnection) {
+                    // Connection type - wrap in nodes/totalCount/pageInfo
+                    const args = [];
+                    if (nested.first !== undefined)
+                        args.push(`first: ${nested.first}`);
+                    if (nested.orderBy?.length)
+                        args.push(`orderBy: [${nested.orderBy.join(', ')}]`);
+                    const argsStr = args.length > 0 ? `(${args.join(', ')})` : '';
+                    fields.push(`${key}${argsStr} {
+      nodes { ${nestedSelections} }
+      totalCount
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }`);
+                }
+                else {
+                    // Regular nested object - just wrap in braces
+                    fields.push(`${key} { ${nestedSelections} }`);
+                }
+            }
+        }
+    }
+    return fields.join('\n    ');
+}
+export function buildFindManyDocument(operationName, queryField, select, args, filterTypeName, orderByTypeName) {
+    const selections = select ? buildSelections(select) : 'id';
+    const varDefs = [];
+    const queryArgs = [];
+    const variables = {};
+    if (args.where) {
+        varDefs.push(`$where: ${filterTypeName}`);
+        queryArgs.push('filter: $where');
+        variables.where = args.where;
+    }
+    if (args.orderBy?.length) {
+        varDefs.push(`$orderBy: [${orderByTypeName}!]`);
+        queryArgs.push('orderBy: $orderBy');
+        variables.orderBy = args.orderBy;
+    }
+    if (args.first !== undefined) {
+        varDefs.push('$first: Int');
+        queryArgs.push('first: $first');
+        variables.first = args.first;
+    }
+    if (args.last !== undefined) {
+        varDefs.push('$last: Int');
+        queryArgs.push('last: $last');
+        variables.last = args.last;
+    }
+    if (args.after) {
+        varDefs.push('$after: Cursor');
+        queryArgs.push('after: $after');
+        variables.after = args.after;
+    }
+    if (args.before) {
+        varDefs.push('$before: Cursor');
+        queryArgs.push('before: $before');
+        variables.before = args.before;
+    }
+    if (args.offset !== undefined) {
+        varDefs.push('$offset: Int');
+        queryArgs.push('offset: $offset');
+        variables.offset = args.offset;
+    }
+    const varDefsStr = varDefs.length > 0 ? `(${varDefs.join(', ')})` : '';
+    const queryArgsStr = queryArgs.length > 0 ? `(${queryArgs.join(', ')})` : '';
+    const document = `query ${operationName}Query${varDefsStr} {
+  ${queryField}${queryArgsStr} {
+    nodes { ${selections} }
+    totalCount
+    pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+  }
+}`;
+    return { document, variables };
+}
+export function buildFindFirstDocument(operationName, queryField, select, args, filterTypeName) {
+    const selections = select ? buildSelections(select) : 'id';
+    const varDefs = ['$first: Int'];
+    const queryArgs = ['first: $first'];
+    const variables = { first: 1 };
+    if (args.where) {
+        varDefs.push(`$where: ${filterTypeName}`);
+        queryArgs.push('filter: $where');
+        variables.where = args.where;
+    }
+    const document = `query ${operationName}Query(${varDefs.join(', ')}) {
+  ${queryField}(${queryArgs.join(', ')}) {
+    nodes { ${selections} }
+  }
+}`;
+    return { document, variables };
+}
+export function buildCreateDocument(operationName, mutationField, entityField, select, data, inputTypeName) {
+    const selections = select ? buildSelections(select) : 'id';
+    const document = `mutation ${operationName}Mutation($input: ${inputTypeName}!) {
+  ${mutationField}(input: $input) {
+    ${entityField} { ${selections} }
+  }
+}`;
+    return {
+        document,
+        variables: { input: { [entityField]: data } },
+    };
+}
+export function buildUpdateDocument(operationName, mutationField, entityField, select, where, data, inputTypeName) {
+    const selections = select ? buildSelections(select) : 'id';
+    const document = `mutation ${operationName}Mutation($input: ${inputTypeName}!) {
+  ${mutationField}(input: $input) {
+    ${entityField} { ${selections} }
+  }
+}`;
+    return {
+        document,
+        variables: { input: { id: where.id, patch: data } },
+    };
+}
+export function buildDeleteDocument(operationName, mutationField, entityField, where, inputTypeName) {
+    const document = `mutation ${operationName}Mutation($input: ${inputTypeName}!) {
+  ${mutationField}(input: $input) {
+    ${entityField} { id }
+  }
+}`;
+    return {
+        document,
+        variables: { input: { id: where.id } },
+    };
+}
+export function buildCustomDocument(operationType, operationName, fieldName, select, args, variableDefinitions) {
+    // Check if select is wrapped with connection metadata
+    let actualSelect = select;
+    let isConnection = false;
+    if (select && typeof select === 'object' && 'select' in select) {
+        const wrapper = select;
+        if (wrapper.select) {
+            actualSelect = wrapper.select;
+            isConnection = wrapper.connection === true;
+        }
+    }
+    const selections = actualSelect ? buildSelections(actualSelect) : '';
+    const varDefs = variableDefinitions.map((v) => `$${v.name}: ${v.type}`);
+    const fieldArgs = variableDefinitions.map((v) => `${v.name}: $${v.name}`);
+    const varDefsStr = varDefs.length > 0 ? `(${varDefs.join(', ')})` : '';
+    const fieldArgsStr = fieldArgs.length > 0 ? `(${fieldArgs.join(', ')})` : '';
+    let selectionsBlock;
+    if (isConnection) {
+        // Wrap in connection structure
+        selectionsBlock = ` {
+    nodes { ${selections} }
+    totalCount
+    pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+  }`;
+    }
+    else {
+        selectionsBlock = selections ? ` { ${selections} }` : '';
+    }
+    const opType = operationType === 'query' ? 'query' : 'mutation';
+    const document = `${opType} ${operationName}${varDefsStr} {
+  ${fieldName}${fieldArgsStr}${selectionsBlock}
+}`;
+    return { document, variables: (args ?? {}) };
+}

package/esm/codegen/orm/select-types.js

@@ -0,0 +1,6 @@
+/**
+ * Type utilities for select inference
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+export {};

package/esm/codegen/orm/types.js

@@ -0,0 +1,7 @@
+/**
+ * Types re-export
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+// Re-export all types from input-types
+export * from './input-types';

package/esm/middleware/api.js

@@ -6,14 +6,14 @@ import { getGraphileSettings } from 'graphile-settings';
 import { getPgPool } from 'pg-cache';
 import errorPage50x from '../errors/50x';
 import errorPage404Message from '../errors/404-message';
-import { ApiByNameQuery, ApiQuery, ListOfAllDomainsOfDb } from './gql';
+import { buildApiByDatabaseIdAndName, buildDomainLookup, buildListApis, } from './gql';
 import './types'; // for Request type
 const log = new Logger('api');
 const isDev = () => 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) => {
@@ -161,10 +161,11 @@ const getMetaSchema = ({ opts, key, databaseId, }) => {
     return svc;
 };
 const queryServiceByDomainAndSubdomain = async ({ opts, key, client, domain, subdomain, }) => {
+    const doc = buildDomainLookup({ domain, subdomain });
     const result = await client.query({
         role: 'administrator',
-        query: ApiQuery,
-        variables: { domain, subdomain },
+        query: doc.document,
+        variables: doc.variables,
     });
     if (result.errors?.length) {
         log.error('GraphQL query errors:', result.errors);
@@ -183,10 +184,11 @@ const queryServiceByDomainAndSubdomain = async ({ opts, key, client, domain, sub
     return null;
 };
 const queryServiceByApiName = async ({ opts, key, client, databaseId, name, }) => {
+    const doc = buildApiByDatabaseIdAndName({ databaseId, name });
     const result = await client.query({
         role: 'administrator',
-        query: ApiByNameQuery,
-        variables: { databaseId, name },
+        query: doc.document,
+        variables: doc.variables,
     });
     if (result.errors?.length) {
         log.error('GraphQL query errors:', result.errors);
@@ -312,8 +314,7 @@ export const getApiConfig = async (opts, req) => {
                     const fallbackResult = await client.query({
                         role: 'administrator',
                         // @ts-ignore
-                        query: ListOfAllDomainsOfDb,
-                        // variables: { databaseId }
+                        query: buildListApis().document,
                     });
                     if (!fallbackResult.errors?.length &&
                         fallbackResult.data?.apis?.nodes?.length) {