introspectron 2.1.4 → 2.2.1

package/esm/gql-types.js

@@ -0,0 +1 @@
+export {};

package/esm/gql.js

@@ -1,4 +1,46 @@
-// @ts-nocheck
+export const parseConnectionQuery = (context, query, nesting) => {
+    const { HASH } = context;
+    const objectType = getObjectType(query.type);
+    const Connection = HASH[objectType];
+    const nodes = Connection.fields.find((f) => f.name === 'nodes');
+    const model = getObjectType(nodes.type);
+    if (nesting === 0) {
+        return {
+            qtype: 'getMany',
+            model,
+            selection: parseSelectionScalar(context, model)
+        };
+    }
+    return {
+        qtype: 'getMany',
+        model,
+        selection: parseSelectionObject(context, model, 1)
+    };
+};
+export const parseSingleQuery = (context, query, nesting) => {
+    const { HASH, getInputForQueries } = context;
+    const model = getObjectType(query.type);
+    if (nesting === 0) {
+        return {
+            qtype: 'getOne',
+            model,
+            properties: query.args.reduce((m2, v) => {
+                m2[v.name] = getInputForQueries(v.type);
+                return m2;
+            }, {}),
+            selection: parseSelectionScalar(context, model)
+        };
+    }
+    return {
+        model,
+        qtype: 'getOne',
+        properties: query.args.reduce((m2, v) => {
+            m2[v.name] = getInputForQueries(v.type);
+            return m2;
+        }, {}),
+        selection: parseSelectionObject(context, model, 1)
+    };
+};
 export const parseGraphQuery = (introQuery) => {
     const types = introQuery.__schema.types;
     const HASH = types.reduce((m, v) => {
@@ -20,43 +62,29 @@ export const parseGraphQuery = (introQuery) => {
             }
             return getInputForQueries(input.ofType, context);
         }
-        if (input.kind === 'INPUT_OBJECT') {
-            if (input.name && HASH.hasOwnProperty(input.name)) {
-                const schema = HASH[input.name];
-                context.properties = schema.inputFields
-                    .map((field) => {
-                    return {
-                        name: field.name,
-                        type: field.type
-                    };
-                })
-                    .reduce((m3, v) => {
-                    m3[v.name] = v;
-                    return m3;
-                }, {});
-            }
+        if (input.kind === 'INPUT_OBJECT' && input.name && HASH.hasOwnProperty(input.name)) {
+            const schema = HASH[input.name];
+            context.properties = schema.inputFields.map((field) => ({ name: field.name, type: field.type })).reduce((m3, v) => {
+                m3[v.name] = v;
+                return m3;
+            }, {});
         }
-        else if (input.kind === 'OBJECT') {
-            if (input.name && HASH.hasOwnProperty(input.name)) {
-                const schema = HASH[input.name];
-                context.properties = schema.fields
-                    .map((field) => {
-                    return {
-                        name: field.name,
-                        type: field.type
-                    };
-                })
-                    .reduce((m3, v) => {
-                    m3[v.name] = v;
-                    return m3;
-                }, {});
-            }
+        else if (input.kind === 'OBJECT' && input.name && HASH.hasOwnProperty(input.name)) {
+            const schema = HASH[input.name];
+            context.properties = schema.fields.map((field) => ({ name: field.name, type: field.type })).reduce((m3, v) => {
+                m3[v.name] = v;
+                return m3;
+            }, {});
         }
         else {
-            context.type = input.name;
+            context.type = input.name ?? null;
         }
         return context;
     };
+    const context = {
+        HASH,
+        getInputForQueries
+    };
     const getInputForMutations = (input, context = {}) => {
         if (input.kind === 'NON_NULL') {
             context.isNotNull = true;
@@ -70,166 +98,70 @@ export const parseGraphQuery = (introQuery) => {
             }
             return getInputForMutations(input.ofType, context);
         }
-        if (input.kind === 'INPUT_OBJECT') {
-            if (input.name && HASH.hasOwnProperty(input.name)) {
-                const schema = HASH[input.name];
-                context.properties = schema.inputFields
-                    .map((field) => {
-                    return getInputForMutations(field.type, { name: field.name });
-                })
-                    .reduce((m3, v) => {
-                    m3[v.name] = v;
-                    return m3;
-                }, {});
-            }
+        if (input.kind === 'INPUT_OBJECT' && input.name && HASH.hasOwnProperty(input.name)) {
+            const schema = HASH[input.name];
+            context.properties = schema.inputFields.map((field) => getInputForMutations(field.type, { name: field.name })).reduce((m3, v) => {
+                m3[v.name] = v;
+                return m3;
+            }, {});
         }
-        else if (input.kind === 'OBJECT') {
-            if (input.name && HASH.hasOwnProperty(input.name)) {
-                const schema = HASH[input.name];
-                context.properties = schema.fields
-                    .map((field) => {
-                    return {
-                        name: field.name,
-                        type: field.type
-                    };
-                })
-                    .reduce((m3, v) => {
-                    m3[v.name] = v;
-                    return m3;
-                }, {});
-            }
+        else if (input.kind === 'OBJECT' && input.name && HASH.hasOwnProperty(input.name)) {
+            const schema = HASH[input.name];
+            context.properties = schema.fields.map((field) => ({ name: field.name, type: field.type })).reduce((m3, v) => {
+                m3[v.name] = v;
+                return m3;
+            }, {});
         }
         else {
-            context.type = input.name;
+            context.type = input.name ?? null;
         }
         return context;
     };
     const mutations = mutationsRoot.fields.reduce((m, mutation) => {
         let mutationType = 'other';
-        if (/^Create/.test(mutation.type.name)) {
+        if (/^Create/.test(mutation.type.name))
             mutationType = 'create';
-        }
-        else if (/^Update/.test(mutation.type.name)) {
+        else if (/^Update/.test(mutation.type.name))
             mutationType = 'patch';
-        }
-        else if (/^Delete/.test(mutation.type.name)) {
+        else if (/^Delete/.test(mutation.type.name))
             mutationType = 'delete';
-        }
         const props = mutation.args.reduce((m2, arg) => {
             const type = arg.type?.ofType?.name;
             const isNotNull = arg.type?.kind === 'NON_NULL';
             if (type && HASH.hasOwnProperty(type)) {
                 const schema = HASH[type];
                 const fields = schema.inputFields.filter((a) => a.name !== 'clientMutationId');
-                const properties = fields
-                    .map((a) => getInputForMutations(a.type, { name: a.name }))
-                    .reduce((m3, v) => {
+                const properties = fields.map((a) => getInputForMutations(a.type, { name: a.name })).reduce((m3, v) => {
                     m3[v.name] = v;
                     return m3;
                 }, {});
-                m2[arg.name] = {
-                    isNotNull,
-                    type,
-                    properties
-                };
-            }
-            else {
-                console.warn('whats wrong with ' + arg);
+                m2[arg.name] = { isNotNull, type, properties };
             }
             return m2;
         }, {});
-        const getModelTypes = (type) => {
-            return type.fields
-                .filter((t) => t.type.kind === 'OBJECT')
-                .filter((t) => t.type.name !== 'Query')
-                .map((f) => ({ name: f.name, type: f.type }));
-        };
+        const getModelTypes = (type) => type.fields.filter((t) => t.type.kind === 'OBJECT' && t.type.name !== 'Query').map((f) => ({ name: f.name, type: f.type }));
         const models = getModelTypes(HASH[mutation.type.name]);
         if (models.length > 0) {
-            // TODO this is probably brittle
             const model = models[0].type.name;
-            m[mutation.name] = {
-                qtype: 'mutation',
-                mutationType,
-                model,
-                properties: props,
-                output: mutation.type
-            };
+            m[mutation.name] = { qtype: 'mutation', mutationType, model, properties: props, output: mutation.type };
         }
         else {
-            // no return args, probably void functions
-            let t;
             let outputFields = [];
             if (mutation.type.kind === 'OBJECT') {
-                t = HASH[mutation.type.name];
-                outputFields = t.fields
-                    .map((f) => ({ name: f.name, type: f.type }))
-                    .filter((f) => f.name !== 'clientMutationId')
-                    .filter((f) => f.type.name !== 'Query');
+                const t = HASH[mutation.type.name];
+                outputFields = t.fields.map((f) => ({ name: f.name, type: f.type })).filter((f) => f.name !== 'clientMutationId' && f.type.name !== 'Query');
             }
-            m[mutation.name] = {
-                qtype: 'mutation',
-                mutationType,
-                properties: props,
-                output: mutation.type,
-                outputs: outputFields
-            };
+            m[mutation.name] = { qtype: 'mutation', mutationType, properties: props, output: mutation.type, outputs: outputFields };
         }
         return m;
     }, {});
-    //   expect(mts).toMatchSnapshot();
-    const parseConnectionQuery = (query, nesting) => {
-        const objectType = getObjectType(query.type);
-        const Connection = HASH[objectType];
-        const nodes = Connection.fields.find((f) => f.name === 'nodes');
-        const edges = Connection.fields.find((f) => f.name === 'edges');
-        const model = getObjectType(nodes.type);
-        const context = { HASH, parseConnectionQuery, parseSingleQuery };
-        if (nesting === 0) {
-            return {
-                qtype: 'getMany',
-                model,
-                selection: parseSelectionScalar(context, model)
-            };
-        }
-        return {
-            qtype: 'getMany',
-            model,
-            selection: parseSelectionObject(context, model, 1)
-        };
-    };
-    const parseSingleQuery = (query, nesting) => {
-        const model = getObjectType(query.type);
-        const context = { HASH, parseConnectionQuery, parseSingleQuery };
-        if (nesting === 0) {
-            return {
-                qtype: 'getOne',
-                model,
-                properties: query.args.reduce((m2, v) => {
-                    m2[v.name] = getInputForQueries(v.type);
-                    return m2;
-                }, {}),
-                selection: parseSelectionScalar(context, model)
-            };
-        }
-        return {
-            model,
-            qtype: 'getOne',
-            properties: query.args.reduce((m2, v) => {
-                m2[v.name] = getInputForQueries(v.type);
-                return m2;
-            }, {}),
-            selection: parseSelectionObject(context, model, 1)
-        };
-    };
     const queries = queriesRoot.fields.reduce((m, query) => {
-        // m[query.name] = getInputForQueries(query.type);
         if (query.type.kind === 'OBJECT') {
             if (isConnectionQuery(query)) {
-                m[query.name] = parseConnectionQuery(query, 1);
+                m[query.name] = parseConnectionQuery(context, query, 1);
             }
             else {
-                m[query.name] = parseSingleQuery(query, 1);
+                m[query.name] = parseSingleQuery(context, query, 1);
             }
         }
         return m;
@@ -239,59 +171,48 @@ export const parseGraphQuery = (introQuery) => {
         mutations
     };
 };
-// Parse selections for both scalar and object fields
 function parseSelectionObject(context, model, nesting) {
-    const { HASH, parseConnectionQuery, parseSingleQuery } = context;
+    const { HASH } = context;
     throwIfInvalidContext(context);
     const selectionFields = HASH[model].fields.filter((f) => !isPureObjectType(f.type));
-    const selection = selectionFields.map((f) => {
+    return selectionFields.map((f) => {
         if (f.type.ofType?.kind === 'OBJECT') {
             if (isConnectionQuery(f)) {
-                return { name: f.name, ...parseConnectionQuery(f, nesting - 1) };
+                return { name: f.name, ...parseConnectionQuery(context, f, nesting - 1) };
             }
             else {
-                return { name: f.name, ...parseSingleQuery(f, nesting - 1) };
+                return { name: f.name, ...parseSingleQuery(context, f, nesting - 1) };
             }
         }
         return f.name;
     });
-    return selection;
 }
-// Parse selections for scalar types only, ignore all field selections
-// that have more nesting selection level
 function parseSelectionScalar(context, model) {
     const { HASH } = context;
     throwIfInvalidContext(context);
     const selectionFields = HASH[model].fields.filter((f) => !isPureObjectType(f.type) && !isConnectionQuery(f));
-    const selection = selectionFields.map((f) => f.name);
-    return selection;
+    return selectionFields.map((f) => f.name);
 }
 function isConnectionQuery(query) {
     const objectType = getObjectType(query.type);
     const fields = query.args.map((a) => a.name);
-    return (/Connection$/.test(objectType) &&
+    return (/Connection$/.test(objectType || '') &&
         fields.includes('condition') &&
         fields.includes('filter'));
 }
-/**
- * Check is a type is pure object type
- * pure object type is different from custom types in the sense that
- * it does not inherit from any type, custom types inherit from a parent type
- * @param {Object} typeObj
- * @returns {boolean}
- */
 function isPureObjectType(typeObj) {
     return typeObj.kind === 'OBJECT' && typeObj.name == null;
 }
 function getObjectType(type) {
     if (type.kind === 'OBJECT')
-        return type.name;
+        return type.name || undefined;
     if (type.ofType)
         return getObjectType(type.ofType);
+    return undefined;
 }
 function throwIfInvalidContext(context) {
-    const { HASH, parseConnectionQuery, parseSingleQuery } = context;
-    if (!HASH || !parseConnectionQuery || !parseSingleQuery) {
+    const { HASH, getInputForQueries } = context;
+    if (!HASH || !getInputForQueries) {
         throw new Error('parseSelection: context missing');
     }
 }

package/esm/index.js

@@ -1,6 +1,7 @@
-// @ts-nocheck
 export * from './introspect';
+export * from './pg-types';
 export * from './process';
 export * from './query';
 export * from './gql';
+export * from './gql-types';
 export * from './introspectGql';

package/esm/introspect.js

@@ -1,17 +1,13 @@
-// @ts-nocheck
 import { makeIntrospectionQuery } from './query';
 import { parseTags } from './utils';
-export const introspect = async (pgClient, { schemas, includeExtensions = false, pgEnableTags = true, pgThrowOnMissingSchema = true } = {}) => {
+export const introspect = async (pgClient, { schemas, includeExtensions = false, pgEnableTags = true, pgThrowOnMissingSchema = true }) => {
     const versionResult = await pgClient.query('show server_version_num;');
     const serverVersionNum = parseInt(versionResult.rows[0].server_version_num, 10);
     const introspectionQuery = makeIntrospectionQuery(serverVersionNum, {
         pgLegacyFunctionsOnly: false,
         pgIgnoreRBAC: true
     });
-    const { rows } = await pgClient.query(introspectionQuery, [
-        schemas,
-        includeExtensions
-    ]);
+    const { rows } = await pgClient.query(introspectionQuery, [schemas, includeExtensions]);
     const result = {
         __pgVersion: serverVersionNum,
         namespace: [],
@@ -26,8 +22,7 @@ export const introspect = async (pgClient, { schemas, includeExtensions = false,
     for (const { object } of rows) {
         result[object.kind].push(object);
     }
-    // Parse tags from comments
-    [
+    const kinds = [
         'namespace',
         'class',
         'attribute',
@@ -36,9 +31,9 @@ export const introspect = async (pgClient, { schemas, includeExtensions = false,
         'procedure',
         'extension',
         'index'
-    ].forEach((kind) => {
-        result[kind].forEach((object) => {
-            // Keep a copy of the raw comment
+    ];
+    for (const kind of kinds) {
+        for (const object of result[kind]) {
             object.comment = object.description;
             if (pgEnableTags && object.description) {
                 const parsed = parseTags(object.description);
@@ -48,38 +43,28 @@ export const introspect = async (pgClient, { schemas, includeExtensions = false,
             else {
                 object.tags = {};
             }
-        });
-    });
-    const extensionConfigurationClassIds = result.extension.flatMap((e) => e.configurationClassIds);
-    result.class.forEach((klass) => {
+        }
+    }
+    const extensionConfigurationClassIds = result.extension.flatMap((e) => e.configurationClassIds || []);
+    for (const klass of result.class) {
         klass.isExtensionConfigurationTable =
-            extensionConfigurationClassIds.indexOf(klass.id) >= 0;
-    });
-    [
-        'namespace',
-        'class',
-        'attribute',
-        'type',
-        'constraint',
-        'procedure',
-        'extension',
-        'index'
-    ].forEach((k) => {
-        result[k].forEach(Object.freeze);
-    });
+            extensionConfigurationClassIds.includes(klass.id);
+    }
+    for (const kind of kinds) {
+        for (const obj of result[kind]) {
+            Object.freeze(obj);
+        }
+    }
     const knownSchemas = result.namespace.map((n) => n.name);
-    const missingSchemas = schemas.filter((s) => knownSchemas.indexOf(s) < 0);
-    if (missingSchemas.length) {
+    const missingSchemas = schemas.filter((s) => !knownSchemas.includes(s));
+    if (missingSchemas.length > 0) {
         const errorMessage = `You requested to use schema '${schemas.join("', '")}'; however we couldn't find some of those! Missing schemas are: '${missingSchemas.join("', '")}'`;
         if (pgThrowOnMissingSchema) {
             throw new Error(errorMessage);
         }
         else {
-            console.warn('⚠️ WARNING⚠️  ' + errorMessage); // eslint-disable-line no-console
+            console.warn('⚠️ WARNING⚠️  ' + errorMessage);
         }
     }
-    // return result;
     return Object.freeze(result);
 };
-// export const processIntrospection = async (pgClient, introspectionResultsByKind) => {
-// }

package/esm/pg-types.js

@@ -0,0 +1 @@
+export {};