graphile-build-pg 5.0.0-beta.2 → 5.0.0-beta.21

package/dist/plugins/PgCodecsPlugin.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PgCodecsPlugin = void 0;
-const tslib_1 = require("tslib");
 const pg_1 = require("@dataplan/pg");
 const graphile_build_1 = require("graphile-build");
-const pg_sql2_1 = tslib_1.__importDefault(require("pg-sql2"));
 const utils_js_1 = require("../utils.js");
 const version_js_1 = require("../version.js");
 exports.PgCodecsPlugin = {
@@ -30,7 +28,10 @@ exports.PgCodecsPlugin = {
             typeCodecName(options, { pgType, serviceName }) {
                 const pgNamespace = pgType.getNamespace();
                 const schemaPrefix = this._schemaPrefix({ pgNamespace, serviceName });
-                return this.camelCase(`${schemaPrefix}${pgType.typname}`);
+                const name = pgType.typcategory === "A" && pgType.typname.startsWith("_")
+                    ? pgType.typname.substring(1) + "_array"
+                    : pgType.typname;
+                return this.camelCase(`${schemaPrefix}${name}`);
             },
             scalarCodecTypeName(options, codec) {
                 return this.upperCamelCase(this.coerceToGraphQLName(codec.extensions?.tags?.name ?? codec.name));
@@ -204,6 +205,8 @@ exports.PgCodecsPlugin = {
                     const tags = Object.assign(Object.create(null), classTagsAndDescription.tags, typeTagsAndDescription.tags);
                     const description = typeTagsAndDescription.description ??
                         classTagsAndDescription.description;
+                    // Do NOT mark `extensions` as `EXPORTABLE` otherwise changes
+                    // implemented through hooks will not be represented in the export.
                     const extensions = {
                         oid: pgClass.reltype,
                         isTableLike: ["r", "v", "m", "f", "p"].includes(pgClass.relkind),
@@ -215,29 +218,25 @@ exports.PgCodecsPlugin = {
                         tags,
                     };
                     const executor = info.helpers.pgIntrospection.getExecutorForService(serviceName);
-                    const spec = (0, graphile_build_1.EXPORTABLE)((attributes, className, codecName, description, executor, extensions, nspName, sql) => ({
+                    const sqlIdent = info.helpers.pgBasics.identifier(nspName, className);
+                    (0, utils_js_1.exportNameHint)(sqlIdent, `${codecName}Identifier`);
+                    (0, utils_js_1.exportNameHint)(attributes, `${codecName}Attributes`);
+                    // Do NOT mark `spec` as `EXPORTABLE` otherwise the changes from
+                    // `pgCodecs_recordType_spec` won't be represented in the export.
+                    const spec = {
                         name: codecName,
-                        identifier: sql.identifier(nspName, className),
+                        identifier: sqlIdent,
                         attributes,
                         description,
                         extensions,
                         executor,
-                    }), [
-                        attributes,
-                        className,
-                        codecName,
-                        description,
-                        executor,
-                        extensions,
-                        nspName,
-                        pg_sql2_1.default,
-                    ]);
+                    };
                     await info.process("pgCodecs_recordType_spec", {
                         serviceName,
                         pgClass,
                         spec,
                     });
-                    const codec = (0, graphile_build_1.EXPORTABLE)((recordCodec, spec) => recordCodec(spec), [pg_1.recordCodec, spec]);
+                    const codec = (0, graphile_build_1.EXPORTABLE)((recordCodec, spec) => recordCodec(spec), [pg_1.recordCodec, spec], `${spec.name}Codec`);
                     await info.process("pgCodecs_PgCodec", {
                         pgCodec: codec,
                         pgType: pgClass.getType(),
@@ -263,47 +262,217 @@ exports.PgCodecsPlugin = {
                     if (!type) {
                         return null;
                     }
-                    const citextExt = await info.helpers.pgIntrospection.getExtensionByName(serviceName, "citext");
-                    const hstoreExt = await info.helpers.pgIntrospection.getExtensionByName(serviceName, "hstore");
-                    const pgCatalog = await info.helpers.pgIntrospection.getNamespaceByName(serviceName, "pg_catalog");
-                    if (!pgCatalog) {
-                        return null;
-                    }
                     // Class types are handled via getCodecFromClass (they have to add attributes)
                     if (type.typtype === "c") {
                         return info.helpers.pgCodecs.getCodecFromClass(serviceName, type.typrelid);
                     }
-                    const codec = await (async () => {
-                        const namespace = await info.helpers.pgIntrospection.getNamespace(serviceName, type.typnamespace);
-                        if (!namespace) {
-                            throw new Error(`Could not get namespace '${type.typnamespace}'`);
-                        }
-                        const namespaceName = namespace.nspname;
-                        // For the standard pg_catalog types, we have standard handling.
-                        // (In v4 we used OIDs for this, but using the name is safer for PostgreSQL-likes.)
-                        if (type.typnamespace == pgCatalog._id) {
-                            const knownType = (0, pg_1.getCodecByPgCatalogTypeName)(type.typname);
-                            if (knownType) {
-                                return knownType;
-                            }
-                        }
-                        if (type.typname === "citext" &&
-                            type.typnamespace === citextExt?.extnamespace) {
-                            return pg_1.TYPES.citext;
-                        }
-                        else if (type.typname === "hstore" &&
-                            type.typnamespace === hstoreExt?.extnamespace) {
-                            return pg_1.TYPES.hstore;
-                        }
-                        // Enum type
-                        if (type.typtype === "e") {
-                            const enumValues = await info.helpers.pgIntrospection.getEnumsForType(serviceName, type._id);
-                            const typeName = type.typname;
-                            const codecName = info.inflection.typeCodecName({
-                                pgType: type,
+                    const event = {
+                        pgCodec: null,
+                        pgType: type,
+                        typeModifier,
+                        serviceName,
+                    };
+                    await info.process("pgCodecs_findPgCodec", event);
+                    if (event.pgCodec) {
+                        const codec = event.pgCodec;
+                        // Be careful not to call this for class codecs!
+                        await info.process("pgCodecs_PgCodec", {
+                            pgCodec: codec,
+                            pgType: type,
+                            serviceName,
+                        });
+                        return codec;
+                    }
+                    else {
+                        console.dir(event);
+                        console.warn(`Could not build PgCodec for '${type.getNamespace()?.nspname ?? "??"}.${type.typname}'; maybe you need a plugin implementing gather.hooks.pgCodecs_findPgCodec to add support.`);
+                        return null;
+                    }
+                })();
+                map.set(typeId, promise);
+                return promise;
+            },
+        },
+        hooks: {
+            async pgCodecs_findPgCodec(info, event) {
+                if (event.pgCodec) {
+                    // Another plugin has already supplied a codec; skip
+                    return;
+                }
+                const { serviceName, pgType: type, typeModifier } = event;
+                const namespace = type.getNamespace();
+                if (!namespace) {
+                    throw new Error(`Could not get namespace '${type.typnamespace}'`);
+                }
+                const namespaceName = namespace.nspname;
+                const pgCatalog = await info.helpers.pgIntrospection.getNamespaceByName(serviceName, "pg_catalog");
+                if (!pgCatalog) {
+                    return;
+                }
+                // For the standard pg_catalog types, we have standard handling.
+                // (In v4 we used OIDs for this, but using the name is safer for PostgreSQL-likes.)
+                if (type.typnamespace == pgCatalog._id) {
+                    const knownType = (0, pg_1.getCodecByPgCatalogTypeName)(type.typname);
+                    if (knownType) {
+                        event.pgCodec = knownType;
+                        return;
+                    }
+                }
+                const citextExt = await info.helpers.pgIntrospection.getExtensionByName(serviceName, "citext");
+                const hstoreExt = await info.helpers.pgIntrospection.getExtensionByName(serviceName, "hstore");
+                if (type.typname === "citext" &&
+                    type.typnamespace === citextExt?.extnamespace) {
+                    event.pgCodec = pg_1.TYPES.citext;
+                    return;
+                }
+                else if (type.typname === "hstore" &&
+                    type.typnamespace === hstoreExt?.extnamespace) {
+                    event.pgCodec = pg_1.TYPES.hstore;
+                    return;
+                }
+                // Enum type
+                if (type.typtype === "e") {
+                    const enumValues = await info.helpers.pgIntrospection.getEnumsForType(serviceName, type._id);
+                    const typeName = type.typname;
+                    const codecName = info.inflection.typeCodecName({
+                        pgType: type,
+                        serviceName,
+                    });
+                    const enumLabels = enumValues.map((e) => e.enumlabel);
+                    const { tags, description } = type.getTagsAndDescription();
+                    const extensions = {
+                        oid: type._id,
+                        pg: {
+                            serviceName,
+                            schemaName: type.getNamespace().nspname,
+                            name: type.typname,
+                        },
+                        tags,
+                    };
+                    await info.process("pgCodecs_enumType_extensions", {
+                        serviceName,
+                        pgType: type,
+                        extensions,
+                    });
+                    const sqlIdent = info.helpers.pgBasics.identifier(namespaceName, typeName);
+                    event.pgCodec = (0, graphile_build_1.EXPORTABLE)((codecName, description, enumCodec, enumLabels, extensions, sqlIdent) => enumCodec({
+                        name: codecName,
+                        identifier: sqlIdent,
+                        values: enumLabels,
+                        description,
+                        extensions,
+                    }), [
+                        codecName,
+                        description,
+                        pg_1.enumCodec,
+                        enumLabels,
+                        extensions,
+                        sqlIdent,
+                    ], `${codecName}Codec`);
+                    return;
+                }
+                // Range type
+                if (type.typtype === "r") {
+                    const range = await info.helpers.pgIntrospection.getRangeByType(serviceName, type._id);
+                    if (!range) {
+                        throw new Error(`Failed to get range entry related to '${type._id}'`);
+                    }
+                    const innerCodec = (await info.helpers.pgCodecs.getCodecFromType(serviceName, range.rngsubtype));
+                    const namespaceName = namespace.nspname;
+                    const typeName = type.typname;
+                    if (!innerCodec) {
+                        console.warn(`PgCodec could not build codec for '${namespaceName}.${typeName}', we don't know how to process the subtype`);
+                        return;
+                    }
+                    const codecName = info.inflection.typeCodecName({
+                        pgType: type,
+                        serviceName,
+                    });
+                    const { tags, description } = type.getTagsAndDescription();
+                    const extensions = {
+                        oid: type._id,
+                        pg: {
+                            serviceName,
+                            schemaName: type.getNamespace().nspname,
+                            name: type.typname,
+                        },
+                        tags,
+                    };
+                    await info.process("pgCodecs_rangeOfCodec_extensions", {
+                        serviceName,
+                        pgType: type,
+                        innerCodec,
+                        extensions,
+                    });
+                    const sqlIdent = info.helpers.pgBasics.identifier(namespaceName, typeName);
+                    event.pgCodec = (0, graphile_build_1.EXPORTABLE)((codecName, description, extensions, innerCodec, rangeOfCodec, sqlIdent) => rangeOfCodec(innerCodec, codecName, sqlIdent, {
+                        description,
+                        extensions,
+                    }), [
+                        codecName,
+                        description,
+                        extensions,
+                        innerCodec,
+                        pg_1.rangeOfCodec,
+                        sqlIdent,
+                    ], `${codecName}Codec`);
+                    return;
+                }
+                // Domains are wrappers under an underlying type
+                if (type.typtype === "d") {
+                    const { typnotnull: notNull, typbasetype: baseTypeOid, typtypmod: baseTypeModifier, typndims: _numberOfArrayDimensions, typcollation: _domainCollation, typdefaultbin: _defaultValueNodeTree, } = type;
+                    const innerCodec = baseTypeOid
+                        ? await info.helpers.pgCodecs.getCodecFromType(serviceName, baseTypeOid, baseTypeModifier)
+                        : null;
+                    const namespaceName = namespace.nspname;
+                    const typeName = type.typname;
+                    if (innerCodec) {
+                        const { tags, description } = type.getTagsAndDescription();
+                        const extensions = {
+                            oid: type._id,
+                            pg: {
                                 serviceName,
-                            });
-                            const enumLabels = enumValues.map((e) => e.enumlabel);
+                                schemaName: type.getNamespace().nspname,
+                                name: type.typname,
+                            },
+                            tags,
+                        };
+                        await info.process("pgCodecs_domainOfCodec_extensions", {
+                            serviceName,
+                            pgType: type,
+                            innerCodec,
+                            extensions,
+                        });
+                        const codecName = info.inflection.typeCodecName({
+                            pgType: type,
+                            serviceName,
+                        });
+                        const sqlIdent = info.helpers.pgBasics.identifier(namespaceName, typeName);
+                        (0, utils_js_1.exportNameHint)(sqlIdent, `${codecName}Identifier`);
+                        event.pgCodec = (0, graphile_build_1.EXPORTABLE)((codecName, description, domainOfCodec, extensions, innerCodec, notNull, sqlIdent) => domainOfCodec(innerCodec, codecName, sqlIdent, {
+                            description,
+                            extensions,
+                            notNull,
+                        }), [
+                            codecName,
+                            description,
+                            pg_1.domainOfCodec,
+                            extensions,
+                            innerCodec,
+                            notNull,
+                            sqlIdent,
+                        ], `${codecName}Codec`);
+                        return;
+                    }
+                }
+                // Array types are just listOfCodec() of their inner type
+                if (type.typcategory === "A") {
+                    const innerType = await info.helpers.pgIntrospection.getTypeByArray(serviceName, type._id);
+                    if (innerType) {
+                        const innerCodec = (await info.helpers.pgCodecs.getCodecFromType(serviceName, innerType._id, typeModifier));
+                        if (innerCodec) {
+                            const typeDelim = innerType.typdelim;
+                            const { tags, description } = type.getTagsAndDescription();
                             const extensions = {
                                 oid: type._id,
                                 pg: {
@@ -311,179 +480,38 @@ exports.PgCodecsPlugin = {
                                     schemaName: type.getNamespace().nspname,
                                     name: type.typname,
                                 },
-                                tags: Object.create(null),
+                                tags,
                             };
-                            await info.process("pgCodecs_enumType_extensions", {
+                            await info.process("pgCodecs_listOfCodec_extensions", {
                                 serviceName,
                                 pgType: type,
+                                innerCodec,
                                 extensions,
                             });
-                            return (0, graphile_build_1.EXPORTABLE)((codecName, enumCodec, enumLabels, extensions, namespaceName, sql, typeName) => enumCodec({
-                                name: codecName,
-                                identifier: sql.identifier(namespaceName, typeName),
-                                values: enumLabels,
-                                extensions,
-                            }), [
-                                codecName,
-                                pg_1.enumCodec,
-                                enumLabels,
-                                extensions,
-                                namespaceName,
-                                pg_sql2_1.default,
-                                typeName,
-                            ]);
-                        }
-                        // Range type
-                        if (type.typtype === "r") {
-                            const range = await info.helpers.pgIntrospection.getRangeByType(serviceName, type._id);
-                            if (!range) {
-                                throw new Error(`Failed to get range entry related to '${type._id}'`);
-                            }
-                            const innerCodec = (await info.helpers.pgCodecs.getCodecFromType(serviceName, range.rngsubtype));
-                            const namespaceName = namespace.nspname;
-                            const typeName = type.typname;
-                            if (!innerCodec) {
-                                console.warn(`PgCodec could not build codec for '${namespaceName}.${typeName}', we don't know how to process the subtype`);
-                                return null;
-                            }
-                            const codecName = info.inflection.typeCodecName({
+                            const name = info.inflection.typeCodecName({
                                 pgType: type,
                                 serviceName,
                             });
-                            const { tags, description } = type.getTagsAndDescription();
-                            const extensions = {
-                                oid: type._id,
-                                pg: {
-                                    serviceName,
-                                    schemaName: type.getNamespace().nspname,
-                                    name: type.typname,
-                                },
-                                tags,
-                            };
-                            await info.process("pgCodecs_rangeOfCodec_extensions", {
-                                serviceName,
-                                pgType: type,
-                                innerCodec,
+                            (0, utils_js_1.exportNameHint)(extensions, `${name}CodecExtensions`);
+                            event.pgCodec = (0, graphile_build_1.EXPORTABLE)((description, extensions, innerCodec, listOfCodec, name, typeDelim) => listOfCodec(innerCodec, {
                                 extensions,
-                            });
-                            return (0, graphile_build_1.EXPORTABLE)((codecName, description, extensions, innerCodec, namespaceName, rangeOfCodec, sql, typeName) => rangeOfCodec(innerCodec, codecName, sql.identifier(namespaceName, typeName), {
+                                typeDelim,
                                 description,
-                                extensions,
+                                name,
                             }), [
-                                codecName,
                                 description,
                                 extensions,
                                 innerCodec,
-                                namespaceName,
-                                pg_1.rangeOfCodec,
-                                pg_sql2_1.default,
-                                typeName,
-                            ]);
-                        }
-                        // Domains are wrappers under an underlying type
-                        if (type.typtype === "d") {
-                            const { typnotnull: notNull, typbasetype: baseTypeOid, typtypmod: baseTypeModifier, typndims: _numberOfArrayDimensions, typcollation: _domainCollation, typdefaultbin: _defaultValueNodeTree, } = type;
-                            const innerCodec = baseTypeOid
-                                ? await info.helpers.pgCodecs.getCodecFromType(serviceName, baseTypeOid, baseTypeModifier)
-                                : null;
-                            const namespaceName = namespace.nspname;
-                            const typeName = type.typname;
-                            if (innerCodec) {
-                                const { tags, description } = type.getTagsAndDescription();
-                                const extensions = {
-                                    oid: type._id,
-                                    pg: {
-                                        serviceName,
-                                        schemaName: type.getNamespace().nspname,
-                                        name: type.typname,
-                                    },
-                                    tags,
-                                };
-                                await info.process("pgCodecs_domainOfCodec_extensions", {
-                                    serviceName,
-                                    pgType: type,
-                                    innerCodec,
-                                    extensions,
-                                });
-                                const codecName = info.inflection.typeCodecName({
-                                    pgType: type,
-                                    serviceName,
-                                });
-                                return (0, graphile_build_1.EXPORTABLE)((codecName, description, domainOfCodec, extensions, innerCodec, namespaceName, notNull, sql, typeName) => domainOfCodec(innerCodec, codecName, sql.identifier(namespaceName, typeName), {
-                                    description,
-                                    extensions,
-                                    notNull,
-                                }), [
-                                    codecName,
-                                    description,
-                                    pg_1.domainOfCodec,
-                                    extensions,
-                                    innerCodec,
-                                    namespaceName,
-                                    notNull,
-                                    pg_sql2_1.default,
-                                    typeName,
-                                ]);
-                            }
-                        }
-                        // Array types are just listOfCodec() of their inner type
-                        if (type.typcategory === "A") {
-                            const innerType = await info.helpers.pgIntrospection.getTypeByArray(serviceName, type._id);
-                            if (innerType) {
-                                const innerCodec = (await info.helpers.pgCodecs.getCodecFromType(serviceName, innerType._id, typeModifier));
-                                if (innerCodec) {
-                                    const typeDelim = innerType.typdelim;
-                                    const { tags, description } = type.getTagsAndDescription();
-                                    const extensions = {
-                                        oid: type._id,
-                                        pg: {
-                                            serviceName,
-                                            schemaName: type.getNamespace().nspname,
-                                            name: type.typname,
-                                        },
-                                        tags,
-                                    };
-                                    await info.process("pgCodecs_listOfCodec_extensions", {
-                                        serviceName,
-                                        pgType: type,
-                                        innerCodec,
-                                        extensions,
-                                    });
-                                    return (0, graphile_build_1.EXPORTABLE)((description, extensions, innerCodec, listOfCodec, typeDelim) => listOfCodec(innerCodec, {
-                                        extensions,
-                                        typeDelim,
-                                        description,
-                                    }), [
-                                        description,
-                                        extensions,
-                                        innerCodec,
-                                        pg_1.listOfCodec,
-                                        typeDelim,
-                                    ]);
-                                }
-                            }
-                            console.warn(`Could not build PgCodec for '${namespaceName}.${type.typname}' due to issue with getting codec for underlying type`);
-                            return null;
+                                pg_1.listOfCodec,
+                                name,
+                                typeDelim,
+                            ], `${name}Codec`);
+                            return;
                         }
-                        // TODO: basic type support
-                        console.warn(`Don't understand how to build type for ${type.typname}`);
-                        return null;
-                    })();
-                    if (codec) {
-                        // Be careful not to call this for class codecs!
-                        await info.process("pgCodecs_PgCodec", {
-                            pgCodec: codec,
-                            pgType: type,
-                            serviceName,
-                        });
                     }
-                    return codec;
-                })();
-                map.set(typeId, promise);
-                return promise;
+                    return;
+                }
             },
-        },
-        hooks: {
             async pgRegistry_PgRegistryBuilder_pgCodecs(info, event) {
                 const { registryBuilder } = event;
                 const codecs = new Set();
@@ -849,8 +877,9 @@ exports.PgCodecsPlugin = {
                             else if (codec.domainOfCodec) {
                                 // We just want to be a copy of the underlying type spec, but with a different name/description
                                 const copy = (underlyingTypeName) => () => {
-                                    const baseType = build.getTypeByName(underlyingTypeName);
-                                    const config = { ...baseType?.toConfig() };
+                                    const details = build.getTypeMetaByName(underlyingTypeName);
+                                    const baseConfig = details?.specGenerator();
+                                    const config = { ...baseConfig };
                                     delete config.name;
                                     delete config.description;
                                     return config;
@@ -916,7 +945,7 @@ exports.PgCodecsPlugin = {
                         else {
                             // We have no idea what this is or how to handle it.
                             // TODO: add some default handling, like "behavesLike = TYPES.text"?
-                            console.warn(`PgCodec '${codec.name}' not understood, please set 'domainOfCodec' to indicate the underlying behaviour the type should have when exposed to GraphQL`);
+                            console.warn(`Do not know how to convert PgCodec '${codec.name}' into a GraphQL type; please use \`build.setGraphQLTypeForPgCodec(codec, mode, typeName)\` inside \`plugin.schema.hooks.init\` for each mode/typeName combo you want to support.`);
                         }
                     }
                     const visited = new Set();