introspectron 0.2.12 → 2.0.3

package/gql.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGraphQuery = void 0;
+// @ts-nocheck
+const parseGraphQuery = (introQuery) => {
+    const types = introQuery.__schema.types;
+    const HASH = types.reduce((m, v) => {
+        m[v.name] = v;
+        return m;
+    }, {});
+    const queriesRoot = types.find((t) => t.name === 'Query');
+    const mutationsRoot = types.find((t) => t.name === 'Mutation');
+    const getInputForQueries = (input, context = {}) => {
+        if (input.kind === 'NON_NULL') {
+            context.isNotNull = true;
+            return getInputForQueries(input.ofType, context);
+        }
+        if (input.kind === 'LIST') {
+            context.isArray = true;
+            if (context.isNotNull) {
+                context.isArrayNotNull = true;
+                delete context.isNotNull;
+            }
+            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;
+                }, {});
+            }
+        }
+        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 {
+            context.type = input.name;
+        }
+        return context;
+    };
+    const getInputForMutations = (input, context = {}) => {
+        if (input.kind === 'NON_NULL') {
+            context.isNotNull = true;
+            return getInputForMutations(input.ofType, context);
+        }
+        if (input.kind === 'LIST') {
+            context.isArray = true;
+            if (context.isNotNull) {
+                context.isArrayNotNull = true;
+                delete context.isNotNull;
+            }
+            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;
+                }, {});
+            }
+        }
+        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 {
+            context.type = input.name;
+        }
+        return context;
+    };
+    const mutations = mutationsRoot.fields.reduce((m, mutation) => {
+        let mutationType = 'other';
+        if (/^Create/.test(mutation.type.name)) {
+            mutationType = 'create';
+        }
+        else if (/^Update/.test(mutation.type.name)) {
+            mutationType = 'patch';
+        }
+        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) => {
+                    m3[v.name] = v;
+                    return m3;
+                }, {});
+                m2[arg.name] = {
+                    isNotNull,
+                    type,
+                    properties
+                };
+            }
+            else {
+                console.warn('whats wrong with ' + arg);
+            }
+            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 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
+            };
+        }
+        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');
+            }
+            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);
+            }
+            else {
+                m[query.name] = parseSingleQuery(query, 1);
+            }
+        }
+        return m;
+    }, {});
+    return {
+        queries,
+        mutations
+    };
+};
+exports.parseGraphQuery = parseGraphQuery;
+// Parse selections for both scalar and object fields
+function parseSelectionObject(context, model, nesting) {
+    const { HASH, parseConnectionQuery, parseSingleQuery } = context;
+    throwIfInvalidContext(context);
+    const selectionFields = HASH[model].fields.filter((f) => !isPureObjectType(f.type));
+    const selection = selectionFields.map((f) => {
+        if (f.type.ofType?.kind === 'OBJECT') {
+            if (isConnectionQuery(f)) {
+                return { name: f.name, ...parseConnectionQuery(f, nesting - 1) };
+            }
+            else {
+                return { name: f.name, ...parseSingleQuery(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;
+}
+function isConnectionQuery(query) {
+    const objectType = getObjectType(query.type);
+    const fields = query.args.map((a) => a.name);
+    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;
+    if (type.ofType)
+        return getObjectType(type.ofType);
+}
+function throwIfInvalidContext(context) {
+    const { HASH, parseConnectionQuery, parseSingleQuery } = context;
+    if (!HASH || !parseConnectionQuery || !parseSingleQuery) {
+        throw new Error('parseSelection: context missing');
+    }
+}

package/{module/index.js → index.d.ts}

@@ -2,4 +2,4 @@ export * from './introspect';
 export * from './process';
 export * from './query';
 export * from './gql';
-export * from './introspectGql';
+export * from './introspectGql';

package/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./process"), exports);
+__exportStar(require("./query"), exports);
+__exportStar(require("./gql"), exports);
+__exportStar(require("./introspectGql"), exports);

package/introspect.d.ts

@@ -0,0 +1,16 @@
+export declare const introspect: (pgClient: any, { schemas, includeExtensions, pgEnableTags, pgThrowOnMissingSchema }?: {
+    schemas: any;
+    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[];
+}>>;

package/introspect.js

@@ -0,0 +1,89 @@
+"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 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 result = {
+        __pgVersion: serverVersionNum,
+        namespace: [],
+        class: [],
+        attribute: [],
+        type: [],
+        constraint: [],
+        procedure: [],
+        extension: [],
+        index: []
+    };
+    for (const { object } of rows) {
+        result[object.kind].push(object);
+    }
+    // Parse tags from comments
+    [
+        'namespace',
+        'class',
+        'attribute',
+        'type',
+        'constraint',
+        'procedure',
+        'extension',
+        'index'
+    ].forEach((kind) => {
+        result[kind].forEach((object) => {
+            // Keep a copy of the raw comment
+            object.comment = object.description;
+            if (pgEnableTags && object.description) {
+                const parsed = (0, utils_1.parseTags)(object.description);
+                object.tags = parsed.tags;
+                object.description = parsed.text;
+            }
+            else {
+                object.tags = {};
+            }
+        });
+    });
+    const extensionConfigurationClassIds = result.extension.flatMap((e) => e.configurationClassIds);
+    result.class.forEach((klass) => {
+        klass.isExtensionConfigurationTable =
+            extensionConfigurationClassIds.indexOf(klass.id) >= 0;
+    });
+    [
+        'namespace',
+        'class',
+        'attribute',
+        'type',
+        'constraint',
+        'procedure',
+        'extension',
+        'index'
+    ].forEach((k) => {
+        result[k].forEach(Object.freeze);
+    });
+    const knownSchemas = result.namespace.map((n) => n.name);
+    const missingSchemas = schemas.filter((s) => knownSchemas.indexOf(s) < 0);
+    if (missingSchemas.length) {
+        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
+        }
+    }
+    // return result;
+    return Object.freeze(result);
+};
+exports.introspect = introspect;
+// export const processIntrospection = async (pgClient, introspectionResultsByKind) => {
+// }

package/introspectGql.d.ts

@@ -0,0 +1 @@
+export declare const IntrospectionQuery: import("graphql/language/ast").DocumentNode;

package/introspectGql.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntrospectionQuery = void 0;
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+exports.IntrospectionQuery = (0, graphql_tag_1.default) `
+  query IntrospectionQuery {
+    __schema {
+      queryType {
+        name
+      }
+      mutationType {
+        name
+      }
+      subscriptionType {
+        name
+      }
+      types {
+        ...FullType
+      }
+      directives {
+        name
+        description
+        locations
+        args {
+          ...InputValue
+        }
+      }
+    }
+  }
+  fragment FullType on __Type {
+    kind
+    name
+    description
+    fields(includeDeprecated: true) {
+      name
+      description
+      args {
+        ...InputValue
+      }
+      type {
+        ...TypeRef
+      }
+      isDeprecated
+      deprecationReason
+    }
+    inputFields {
+      ...InputValue
+    }
+    interfaces {
+      ...TypeRef
+    }
+    enumValues(includeDeprecated: true) {
+      name
+      description
+      isDeprecated
+      deprecationReason
+    }
+    possibleTypes {
+      ...TypeRef
+    }
+  }
+  fragment InputValue on __InputValue {
+    name
+    description
+    type {
+      ...TypeRef
+    }
+    defaultValue
+  }
+  fragment TypeRef on __Type {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;

package/package.json

@@ -1,71 +1,36 @@
 {
   "name": "introspectron",
-  "version": "0.2.12",
+  "version": "2.0.3",
   "description": "introspect your Postgres database and generate an SDK",
   "author": "Dan Lynch <pyramation@gmail.com>",
-  "homepage": "https://github.com/launchql/launchql-gen/tree/master/packages/introspectron#readme",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/launchql/launchql",
   "license": "SEE LICENSE IN LICENSE",
-  "main": "main/index.js",
-  "module": "module/index.js",
-  "directories": {
-    "lib": "src",
-    "test": "__tests__"
-  },
-  "files": [
-    "main",
-    "module"
-  ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "directory": "dist"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/launchql/launchql-gen"
+    "url": "https://github.com/launchql/launchql"
+  },
+  "bugs": {
+    "url": "https://github.com/launchql/launchql/issues"
   },
   "scripts": {
-    "build:main": "BABEL_ENV=production babel src --out-dir main --delete-dir-on-start",
-    "build:module": "MODULE=true babel src --out-dir module --delete-dir-on-start",
-    "build": "npm run build:module && npm run build:main",
-    "clean": "rimraf node_modules main module",
-    "debug": "node --inspect-brk ../../node_modules/jest/bin/jest.js --runInBand ./__tests__",
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist/**",
     "prepare": "npm run build",
-    "lint": "eslint src --fix",
+    "build": "npm run clean; tsc; tsc -p tsconfig.esm.json; npm run copy",
+    "build:dev": "npm run clean; tsc --declarationMap; tsc -p tsconfig.esm.json; npm run copy",
+    "lint": "eslint . --fix",
     "test": "jest",
-    "test:watch": "jest --watch",
-    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
-  },
-  "bugs": {
-    "url": "https://github.com/launchql/launchql-gen/issues"
-  },
-  "devDependencies": {
-    "@babel/cli": "7.8.4",
-    "@babel/core": "7.8.4",
-    "@babel/plugin-proposal-class-properties": "7.8.3",
-    "@babel/plugin-proposal-export-default-from": "7.8.3",
-    "@babel/plugin-proposal-object-rest-spread": "7.9.6",
-    "@babel/plugin-transform-runtime": "7.9.6",
-    "@babel/preset-env": "7.13.0",
-    "@babel/preset-react": "7.9.4",
-    "babel-core": "7.0.0-bridge.0",
-    "babel-eslint": "10.0.3",
-    "babel-plugin-macros": "2.8.0",
-    "eslint": "^6.8.0",
-    "eslint-config-prettier": "^6.10.0",
-    "eslint-config-react-app": "5.2.0",
-    "eslint-plugin-prettier": "^3.1.2",
-    "eslint-plugin-react": "^7.18.3",
-    "eslint-plugin-react-hooks": "4.0.0",
-    "jest": "^25.1.0",
-    "json-stringify-safe": "5.0.1",
-    "pg": "8.3.3",
-    "prettier": "^1.19.1",
-    "regenerator-runtime": "^0.13.2",
-    "rimraf": "^3.0.2"
+    "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@babel/runtime": "^7.4.2",
-    "graphql-tag": "2.11.0",
-    "lodash": "4.17.20"
+    "graphql-tag": "2.12.5"
   },
-  "gitHead": "9a2a378c93c58d4602c148fd324427e01a91f473"
+  "gitHead": "546607b8de61b57f332562bfd8418cd5fac63a6a"
 }

package/process.d.ts

@@ -0,0 +1 @@
+export declare const introspectionResultsFromRaw: (rawResults: any, pgAugmentIntrospectionResults: any) => any;