@constructive-io/graphql-server 3.1.1 → 4.0.1

package/esm/middleware/gql.js

@@ -1,116 +0,0 @@
-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,
-    anonRole: true,
-    isPublic: true,
-    domains: {
-        select: {
-            subdomain: true,
-            domain: true,
-        },
-        first: connectionFirst,
-    },
-    schemasByApiSchemaApiIdAndSchemaId: {
-        select: { schemaName: true },
-        first: connectionFirst,
-    },
-    rlsModule: {
-        select: {
-            privateSchema: { select: { schemaName: true } },
-            authenticateStrict: true,
-            authenticate: true,
-            currentRole: true,
-            currentRoleId: true,
-        },
-    },
-    apiModules: {
-        select: { name: true, data: true },
-        first: connectionFirst,
-    },
-};
-export const domainSelect = {
-    domain: true,
-    subdomain: true,
-    api: { select: apiSelect },
-};
-export const apiListSelect = {
-    id: true,
-    databaseId: true,
-    name: true,
-    dbname: true,
-    roleName: true,
-    anonRole: true,
-    isPublic: true,
-    domains: {
-        select: { domain: true, subdomain: true },
-        first: connectionFirst,
-    },
-};
-class GraphileOrmClient extends OrmClient {
-    graphile;
-    constructor(graphile) {
-        super({ endpoint: 'http://localhost/graphql' });
-        this.graphile = graphile;
-    }
-    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,
-        };
-    }
-}
-export const createGraphileOrm = (graphile) => {
-    const client = new GraphileOrmClient(graphile);
-    return {
-        api: new ApiModel(client),
-        domain: new DomainModel(client),
-        query: createQueryOperations(client),
-    };
-};
-export const normalizeApiRecord = (api) => {
-    const schemaNames = (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,
-        apiModules: api.apiModules?.nodes?.map((node) => ({
-            name: node.name,
-            data: node.data,
-        })) || [],
-        rlsModule: api.rlsModule,
-        domains,
-        databaseId: api.databaseId,
-        isPublic: api.isPublic,
-    };
-};

package/esm/plugins/PublicKeySignature.js

@@ -1,114 +0,0 @@
-import { gql, makeExtendSchemaPlugin } from 'graphile-utils';
-import pgQueryWithContext from 'pg-query-context';
-export const PublicKeySignature = (pubkey_challenge) => {
-    const { schema, crypto_network, sign_up_with_key, sign_in_request_challenge, sign_in_record_failure, sign_in_with_challenge } = pubkey_challenge;
-    return makeExtendSchemaPlugin(() => ({
-        typeDefs: gql `
-      input CreateUserAccountWithPublicKeyInput {
-        publicKey: String!
-      }
-
-      input GetMessageForSigningInput {
-        publicKey: String!
-      }
-
-      input VerifyMessageForSigningInput {
-        publicKey: String!
-        message: String!
-        signature: String!
-      }
-
-      type createUserAccountWithPublicKeyPayload {
-        message: String!
-      }
-
-      type getMessageForSigningPayload {
-        message: String!
-      }
-
-      type verifyMessageForSigningPayload {
-        access_token: String!
-        access_token_expires_at: Datetime!
-      }
-
-      extend type Mutation {
-        createUserAccountWithPublicKey(
-          input: CreateUserAccountWithPublicKeyInput
-        ): createUserAccountWithPublicKeyPayload
-
-        getMessageForSigning(
-          input: GetMessageForSigningInput
-        ): getMessageForSigningPayload
-
-        verifyMessageForSigning(
-          input: VerifyMessageForSigningInput
-        ): verifyMessageForSigningPayload
-      }
-    `,
-        resolvers: {
-            Mutation: {
-                async createUserAccountWithPublicKey(_parent, args, context) {
-                    const { pgClient } = context;
-                    const { publicKey } = args.input;
-                    await pgQueryWithContext({
-                        client: pgClient,
-                        context: { role: 'anonymous' },
-                        query: `SELECT * FROM "${schema}".${sign_up_with_key}($1)`,
-                        variables: [publicKey]
-                    });
-                    const { rows: [{ [sign_in_request_challenge]: message }] } = await pgQueryWithContext({
-                        client: pgClient,
-                        context: { role: 'anonymous' },
-                        query: `SELECT * FROM "${schema}".${sign_in_request_challenge}($1)`,
-                        variables: [publicKey]
-                    });
-                    return { message };
-                },
-                async getMessageForSigning(_parent, args, context) {
-                    const { pgClient } = context;
-                    const { publicKey } = args.input;
-                    const { rows: [{ [sign_in_request_challenge]: message }] } = await pgQueryWithContext({
-                        client: pgClient,
-                        context: { role: 'anonymous' },
-                        query: `SELECT * FROM "${schema}".${sign_in_request_challenge}($1)`,
-                        variables: [publicKey]
-                    });
-                    if (!message)
-                        throw new Error('NO_ACCOUNT_EXISTS');
-                    return { message };
-                },
-                async verifyMessageForSigning(_parent, args, context) {
-                    const { pgClient } = context;
-                    const { publicKey, message, signature } = args.input;
-                    //   const network = Networks[crypto_network];
-                    const network = 'btc';
-                    //   const result = verifyMessage(message, publicKey, signature, network);
-                    // TODO implement using interchainJS?
-                    const result = false;
-                    if (!result) {
-                        await pgQueryWithContext({
-                            client: pgClient,
-                            context: { role: 'anonymous' },
-                            query: `SELECT * FROM "${schema}".${sign_in_record_failure}($1)`,
-                            variables: [publicKey]
-                        });
-                        throw new Error('BAD_SIGNIN');
-                    }
-                    const { rows: [token] } = await pgQueryWithContext({
-                        client: pgClient,
-                        context: { role: 'anonymous' },
-                        query: `SELECT * FROM "${schema}".${sign_in_with_challenge}($1, $2)`,
-                        variables: [publicKey, message]
-                    });
-                    if (!token?.access_token)
-                        throw new Error('BAD_SIGNIN');
-                    return {
-                        access_token: token.access_token,
-                        access_token_expires_at: token.access_token_expires_at
-                    };
-                }
-            }
-        }
-    }));
-};
-export default PublicKeySignature;

package/esm/scripts/codegen-schema.js

@@ -1,71 +0,0 @@
-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/scripts/create-bucket.js

@@ -1,40 +0,0 @@
-// Minimal script to create a bucket in MinIO/S3 using @constructive-io/s3-utils
-// Avoid strict type coupling between different @aws-sdk/client-s3 versions
-import { S3Client } from '@aws-sdk/client-s3';
-import { createS3Bucket } from '@constructive-io/s3-utils';
-import { getEnvOptions } from '@constructive-io/graphql-env';
-import { Logger } from '@pgpmjs/logger';
-const log = new Logger('create-bucket');
-(async () => {
-    try {
-        const opts = getEnvOptions();
-        const { cdn } = opts;
-        const provider = cdn?.provider || 'minio';
-        const isMinio = provider === 'minio';
-        const bucket = cdn?.bucketName || 'test-bucket';
-        const region = cdn?.awsRegion || 'us-east-1';
-        const accessKey = cdn?.awsAccessKey || 'minioadmin';
-        const secretKey = cdn?.awsSecretKey || 'minioadmin';
-        const endpoint = cdn?.minioEndpoint || 'http://localhost:9000';
-        const client = new S3Client({
-            region,
-            credentials: { accessKeyId: accessKey, secretAccessKey: secretKey },
-            ...(isMinio ? {
-                endpoint,
-                forcePathStyle: true,
-            } : {}),
-        });
-        const res = await createS3Bucket(client, bucket, { provider });
-        if (res.success) {
-            log.success(`${bucket} (provider: ${provider})`);
-        }
-        else {
-            log.error(`Failed to create bucket ${bucket}`);
-        }
-        client.destroy();
-    }
-    catch (e) {
-        log.error('error', e);
-        process.exitCode = 1;
-    }
-})();

package/middleware/gql.d.ts

@@ -1,164 +0,0 @@
-import { GraphileQuery } from 'graphile-query';
-import { type ApiSelect, type ApiWithRelations, type DomainFilter, type DomainWithRelations } from '../codegen/orm/input-types';
-import { type QueryResult } from '../codegen/orm/client';
-import { ApiModel, DomainModel } from '../codegen/orm/models';
-import type { InferSelectResult } from '../codegen/orm/select-types';
-import { ApiStructure } from '../types';
-export declare const connectionFirst = 1000;
-export declare const apiSelect: {
-    databaseId: true;
-    dbname: true;
-    roleName: true;
-    anonRole: true;
-    isPublic: true;
-    domains: {
-        select: {
-            subdomain: true;
-            domain: true;
-        };
-        first: number;
-    };
-    schemasByApiSchemaApiIdAndSchemaId: {
-        select: {
-            schemaName: true;
-        };
-        first: number;
-    };
-    rlsModule: {
-        select: {
-            privateSchema: {
-                select: {
-                    schemaName: true;
-                };
-            };
-            authenticateStrict: true;
-            authenticate: true;
-            currentRole: true;
-            currentRoleId: true;
-        };
-    };
-    apiModules: {
-        select: {
-            name: true;
-            data: true;
-        };
-        first: number;
-    };
-};
-export declare const domainSelect: {
-    domain: true;
-    subdomain: true;
-    api: {
-        select: {
-            databaseId: true;
-            dbname: true;
-            roleName: true;
-            anonRole: true;
-            isPublic: true;
-            domains: {
-                select: {
-                    subdomain: true;
-                    domain: true;
-                };
-                first: number;
-            };
-            schemasByApiSchemaApiIdAndSchemaId: {
-                select: {
-                    schemaName: true;
-                };
-                first: number;
-            };
-            rlsModule: {
-                select: {
-                    privateSchema: {
-                        select: {
-                            schemaName: true;
-                        };
-                    };
-                    authenticateStrict: true;
-                    authenticate: true;
-                    currentRole: true;
-                    currentRoleId: true;
-                };
-            };
-            apiModules: {
-                select: {
-                    name: true;
-                    data: true;
-                };
-                first: number;
-            };
-        };
-    };
-};
-export declare const apiListSelect: {
-    id: true;
-    databaseId: true;
-    name: true;
-    dbname: true;
-    roleName: true;
-    anonRole: true;
-    isPublic: true;
-    domains: {
-        select: {
-            domain: true;
-            subdomain: true;
-        };
-        first: number;
-    };
-};
-export type ApiRecord = InferSelectResult<ApiWithRelations, typeof apiSelect>;
-export type DomainRecord = InferSelectResult<DomainWithRelations, typeof domainSelect>;
-export type ApiListRecord = InferSelectResult<ApiWithRelations, typeof apiListSelect>;
-type ApiByNameResult = QueryResult<{
-    apiByDatabaseIdAndName: ApiRecord;
-}>;
-export type ApiQueryOps = {
-    apiByDatabaseIdAndName: (args: {
-        databaseId: string;
-        name: string;
-    }, options: {
-        select: typeof apiSelect;
-    }) => {
-        execute: () => Promise<ApiByNameResult>;
-    };
-};
-type DomainLookupResult = QueryResult<{
-    domains: {
-        nodes: DomainRecord[];
-    };
-}>;
-export type DomainLookupModel = {
-    findFirst: (args: {
-        select: typeof domainSelect;
-        where: DomainFilter;
-    }) => {
-        execute: () => Promise<DomainLookupResult>;
-    };
-};
-type ApiListResult = QueryResult<{
-    apis: {
-        nodes: ApiListRecord[];
-    };
-}>;
-export type ApiListModel = {
-    findMany: (args: {
-        select: typeof apiListSelect;
-        first: number;
-    }) => {
-        execute: () => Promise<ApiListResult>;
-    };
-};
-export declare const createGraphileOrm: (graphile: GraphileQuery) => {
-    api: ApiModel;
-    domain: DomainModel;
-    query: {
-        apiByDatabaseIdAndName: <const S extends ApiSelect>(args: import("../codegen/orm/query").ApiByDatabaseIdAndNameVariables, options?: {
-            select?: import("../codegen/orm/select-types").DeepExact<S, ApiSelect>;
-        }) => import("../codegen/orm").QueryBuilder<{
-            apiByDatabaseIdAndName: InferSelectResult<import("../codegen/orm/input-types").Api, S>;
-        }>;
-    };
-};
-export declare const normalizeApiRecord: (api: ApiRecord) => ApiStructure;
-export {};

package/middleware/gql.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeApiRecord = exports.createGraphileOrm = exports.apiListSelect = exports.domainSelect = exports.apiSelect = exports.connectionFirst = void 0;
-const client_1 = require("../codegen/orm/client");
-const models_1 = require("../codegen/orm/models");
-const query_1 = require("../codegen/orm/query");
-exports.connectionFirst = 1000;
-exports.apiSelect = {
-    databaseId: true,
-    dbname: true,
-    roleName: true,
-    anonRole: true,
-    isPublic: true,
-    domains: {
-        select: {
-            subdomain: true,
-            domain: true,
-        },
-        first: exports.connectionFirst,
-    },
-    schemasByApiSchemaApiIdAndSchemaId: {
-        select: { schemaName: true },
-        first: exports.connectionFirst,
-    },
-    rlsModule: {
-        select: {
-            privateSchema: { select: { schemaName: true } },
-            authenticateStrict: true,
-            authenticate: true,
-            currentRole: true,
-            currentRoleId: true,
-        },
-    },
-    apiModules: {
-        select: { name: true, data: true },
-        first: exports.connectionFirst,
-    },
-};
-exports.domainSelect = {
-    domain: true,
-    subdomain: true,
-    api: { select: exports.apiSelect },
-};
-exports.apiListSelect = {
-    id: true,
-    databaseId: true,
-    name: true,
-    dbname: true,
-    roleName: true,
-    anonRole: true,
-    isPublic: true,
-    domains: {
-        select: { domain: true, subdomain: true },
-        first: exports.connectionFirst,
-    },
-};
-class GraphileOrmClient extends client_1.OrmClient {
-    graphile;
-    constructor(graphile) {
-        super({ endpoint: 'http://localhost/graphql' });
-        this.graphile = graphile;
-    }
-    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,
-        };
-    }
-}
-const createGraphileOrm = (graphile) => {
-    const client = new GraphileOrmClient(graphile);
-    return {
-        api: new models_1.ApiModel(client),
-        domain: new models_1.DomainModel(client),
-        query: (0, query_1.createQueryOperations)(client),
-    };
-};
-exports.createGraphileOrm = createGraphileOrm;
-const normalizeApiRecord = (api) => {
-    const schemaNames = (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,
-        apiModules: api.apiModules?.nodes?.map((node) => ({
-            name: node.name,
-            data: node.data,
-        })) || [],
-        rlsModule: api.rlsModule,
-        domains,
-        databaseId: api.databaseId,
-        isPublic: api.isPublic,
-    };
-};
-exports.normalizeApiRecord = normalizeApiRecord;

package/plugins/PublicKeySignature.d.ts

@@ -1,11 +0,0 @@
-import type { Plugin } from 'graphile-build';
-export interface PublicKeyChallengeConfig {
-    schema: string;
-    crypto_network: string;
-    sign_up_with_key: string;
-    sign_in_request_challenge: string;
-    sign_in_record_failure: string;
-    sign_in_with_challenge: string;
-}
-export declare const PublicKeySignature: (pubkey_challenge: PublicKeyChallengeConfig) => Plugin;
-export default PublicKeySignature;