introspectron 2.1.4 → 2.2.1

package/gql.js

@@ -1,7 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseGraphQuery = void 0;
-// @ts-nocheck
+exports.parseGraphQuery = exports.parseSingleQuery = exports.parseConnectionQuery = void 0;
+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)
+    };
+};
+exports.parseConnectionQuery = parseConnectionQuery;
+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)
+    };
+};
+exports.parseSingleQuery = parseSingleQuery;
 const parseGraphQuery = (introQuery) => {
     const types = introQuery.__schema.types;
     const HASH = types.reduce((m, v) => {
@@ -23,43 +67,29 @@ 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;
@@ -73,166 +103,70 @@ 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] = (0, exports.parseConnectionQuery)(context, query, 1);
             }
             else {
-                m[query.name] = parseSingleQuery(query, 1);
+                m[query.name] = (0, exports.parseSingleQuery)(context, query, 1);
             }
         }
         return m;
@@ -243,59 +177,48 @@ const parseGraphQuery = (introQuery) => {
     };
 };
 exports.parseGraphQuery = parseGraphQuery;
-// 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, ...(0, exports.parseConnectionQuery)(context, f, nesting - 1) };
             }
             else {
-                return { name: f.name, ...parseSingleQuery(f, nesting - 1) };
+                return { name: f.name, ...(0, exports.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/index.d.ts

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

package/index.js

@@ -14,9 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
 __exportStar(require("./introspect"), exports);
+__exportStar(require("./pg-types"), exports);
 __exportStar(require("./process"), exports);
 __exportStar(require("./query"), exports);
 __exportStar(require("./gql"), exports);
+__exportStar(require("./gql-types"), exports);
 __exportStar(require("./introspectGql"), exports);

package/introspect.d.ts

@@ -1,16 +1,10 @@
-export declare const introspect: (pgClient: any, { schemas, includeExtensions, pgEnableTags, pgThrowOnMissingSchema }?: {
-    schemas: any;
+import type { ClientBase } from 'pg';
+import type { PgIntrospectionResultByKind } from './pg-types';
+interface IntrospectOptions {
+    schemas: string[];
     includeExtensions?: boolean;
     pgEnableTags?: boolean;
     pgThrowOnMissingSchema?: boolean;
-}) => Promise<Readonly<{
-    __pgVersion: number;
-    namespace: any[];
-    class: any[];
-    attribute: any[];
-    type: any[];
-    constraint: any[];
-    procedure: any[];
-    extension: any[];
-    index: any[];
-}>>;
+}
+export declare const introspect: (pgClient: ClientBase, { schemas, includeExtensions, pgEnableTags, pgThrowOnMissingSchema }: IntrospectOptions) => Promise<PgIntrospectionResultByKind>;
+export {};

package/introspect.js

@@ -1,20 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.introspect = void 0;
-// @ts-nocheck
 const query_1 = require("./query");
 const utils_1 = require("./utils");
-const introspect = async (pgClient, { schemas, includeExtensions = false, pgEnableTags = true, pgThrowOnMissingSchema = true } = {}) => {
+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 = (0, query_1.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: [],
@@ -29,8 +25,7 @@ const introspect = async (pgClient, { schemas, includeExtensions = false, pgEnab
     for (const { object } of rows) {
         result[object.kind].push(object);
     }
-    // Parse tags from comments
-    [
+    const kinds = [
         'namespace',
         'class',
         'attribute',
@@ -39,9 +34,9 @@ const introspect = async (pgClient, { schemas, includeExtensions = false, pgEnab
         '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 = (0, utils_1.parseTags)(object.description);
@@ -51,39 +46,29 @@ const introspect = async (pgClient, { schemas, includeExtensions = false, pgEnab
             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);
 };
 exports.introspect = introspect;
-// export const processIntrospection = async (pgClient, introspectionResultsByKind) => {
-// }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "introspectron",
-  "version": "2.1.4",
+  "version": "2.2.1",
   "description": "introspect your Postgres database and generate an SDK",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "main": "index.js",
@@ -29,15 +29,20 @@
     "test": "jest",
     "test:watch": "jest --watch"
   },
+  "devDependencies": {
+    "graphile-test": "^2.1.10",
+    "pgsql-test": "^2.1.14"
+  },
   "dependencies": {
-    "graphql-tag": "2.12.5"
+    "graphql-tag": "2.12.6"
   },
   "keywords": [
     "graphql",
     "introspection",
+    "pg",
     "schema",
     "graphile",
     "launchql"
   ],
-  "gitHead": "cc4675c134273a66b11a881d084d04362f6837af"
+  "gitHead": "565af20915f5a737f31f0695423c09ec9abc607f"
 }

package/pg-types.d.ts

@@ -0,0 +1,104 @@
+type WithTags<T> = T & {
+    comment?: string;
+    description?: string;
+    tags: Record<string, string>;
+};
+export type PgNamespace = WithTags<{
+    id: string;
+    name: string;
+}>;
+export type PgClass = WithTags<{
+    id: string;
+    name: string;
+    namespaceId: string;
+    namespaceName: string;
+    typeId?: string;
+    isExtensionConfigurationTable?: boolean;
+    namespace?: PgNamespace;
+    type?: PgType;
+    attributes?: PgAttribute[];
+    canUseAsterisk?: boolean;
+    constraints?: PgConstraint[];
+    foreignConstraints?: PgConstraint[];
+    primaryKeyConstraint?: PgConstraint;
+}>;
+export type PgAttribute = WithTags<{
+    id: string;
+    classId: string;
+    name: string;
+    num: number;
+    typeId: string;
+    class?: PgClass;
+    type?: PgType;
+    isIndexed?: boolean;
+    isUnique?: boolean;
+    columnLevelSelectGrant?: boolean;
+}>;
+export type PgType = WithTags<{
+    id: string;
+    name: string;
+    namespaceId: string;
+    type: string;
+    classId?: string;
+    domainBaseTypeId?: string;
+    arrayItemTypeId?: string;
+    namespace?: PgNamespace;
+    class?: PgClass;
+    domainBaseType?: PgType;
+    arrayItemType?: PgType;
+    arrayType?: PgType;
+}>;
+export type PgConstraint = WithTags<{
+    id: string;
+    name: string;
+    classId: string;
+    foreignClassId: string | null;
+    type: 'p' | 'f' | 'u';
+    keyAttributeNums: number[];
+    foreignKeyAttributeNums: number[] | null;
+    isFake?: boolean;
+    isIndexed?: boolean;
+    class?: PgClass;
+    foreignClass?: PgClass;
+    keyAttributes?: PgAttribute[];
+    foreignKeyAttributes?: PgAttribute[];
+}>;
+export type PgProcedure = WithTags<{
+    id: string;
+    name: string;
+    namespaceId: string;
+    namespace?: PgNamespace;
+}>;
+export type PgExtension = WithTags<{
+    id: string;
+    name: string;
+    namespaceId: string;
+    configurationClassIds: string[];
+    namespace?: PgNamespace;
+    configurationClasses?: PgClass[];
+}>;
+export type PgIndex = WithTags<{
+    id: string;
+    name: string;
+    classId: string;
+    attributeNums: number[];
+    isUnique: boolean;
+    class: PgClass;
+}>;
+export interface PgIntrospectionResultByKind {
+    __pgVersion: number;
+    namespace: PgNamespace[];
+    class: PgClass[];
+    attribute: PgAttribute[];
+    type: PgType[];
+    constraint: PgConstraint[];
+    procedure: PgProcedure[];
+    extension: PgExtension[];
+    index: PgIndex[];
+    namespaceById?: Record<string, PgNamespace>;
+    classById?: Record<string, PgClass>;
+    typeById?: Record<string, PgType>;
+    attributeByClassIdAndNum?: Record<string, Record<string, PgAttribute>>;
+    extensionById?: Record<string, PgExtension>;
+}
+export {};

package/pg-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/process.d.ts

@@ -1 +1,2 @@
-export declare const introspectionResultsFromRaw: (rawResults: any, pgAugmentIntrospectionResults: any) => any;
+import type { PgIntrospectionResultByKind } from './pg-types';
+export declare const introspectionResultsFromRaw: (rawResults: PgIntrospectionResultByKind, pgAugmentIntrospectionResults: ((res: PgIntrospectionResultByKind) => void) | null) => PgIntrospectionResultByKind;