@snowtop/ent 0.0.36 → 0.0.39-alpha4

package/graphql/graphql.d.ts

@@ -82,6 +82,9 @@ declare enum NullableResult {
     CONTENTS_AND_LIST = "contentsAndList",
     ITEM = "true"
 }
+export declare const knownAllowedNames: Map<string, string>;
+export declare const knownDisAllowedNames: Map<string, boolean>;
+export declare const isCustomType: (type: Type) => type is CustomType;
 export declare const addCustomType: (type: CustomType) => void;
 export declare class GQLCapture {
     private static enabled;
@@ -107,8 +110,6 @@ export declare class GQLCapture {
     static getProcessedCustomMutations(): ProcessedCustomField[];
     static getProcessedCustomQueries(): ProcessedCustomField[];
     private static getProcessedCustomFieldsImpl;
-    private static knownAllowedNames;
-    private static knownDisAllowedNames;
     private static getResultFromMetadata;
     static gqlField(options?: gqlFieldOptions): any;
     private static getCustomField;

package/graphql/graphql.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gqlFileUpload = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlArg = exports.gqlField = exports.GQLCapture = exports.addCustomType = exports.CustomFieldType = void 0;
+exports.gqlFileUpload = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlArg = exports.gqlField = exports.GQLCapture = exports.addCustomType = exports.isCustomType = exports.knownDisAllowedNames = exports.knownAllowedNames = exports.CustomFieldType = void 0;
 require("reflect-metadata");
 // export interface gqlTopLevelOptions
 //   name?: string;
@@ -20,6 +20,22 @@ var NullableResult;
     NullableResult["CONTENTS_AND_LIST"] = "contentsAndList";
     NullableResult["ITEM"] = "true";
 })(NullableResult || (NullableResult = {}));
+exports.knownAllowedNames = new Map([
+    ["Date", "Date"],
+    ["Boolean", "boolean"],
+    ["Number", "number"],
+    ["String", "string"],
+    // TODO not right to have this and Number
+    ["Int", "number"],
+    ["Float", "number"],
+    ["ID", "ID"],
+]);
+exports.knownDisAllowedNames = new Map([
+    ["Function", true],
+    ["Object", true],
+    ["Array", true],
+    ["Promise", true],
+]);
 const isArray = (type) => {
     if (typeof type === "function") {
         return false;
@@ -41,6 +57,7 @@ const isString = (type) => {
 const isCustomType = (type) => {
     return type.importPath !== undefined;
 };
+exports.isCustomType = isCustomType;
 const isGraphQLScalarType = (type) => {
     return type.serialize !== undefined;
 };
@@ -92,7 +109,7 @@ const getType = (typ, result) => {
         }
         return;
     }
-    if (isCustomType(typ)) {
+    if ((0, exports.isCustomType)(typ)) {
         result.type = typ.type;
         (0, exports.addCustomType)(typ);
         return;
@@ -197,20 +214,20 @@ class GQLCapture {
             connection = r.connection;
             type = r.type;
         }
-        if (GQLCapture.knownDisAllowedNames.has(type)) {
+        if (exports.knownDisAllowedNames.has(type)) {
             throw new Error(`${type} isn't a valid type for accessor/function/property`);
         }
         let result = {
             name: metadata.paramName || "",
             type,
-            tsType: this.knownAllowedNames.get(type) || this.customTypes.get(type)?.tsType,
+            tsType: exports.knownAllowedNames.get(type) || this.customTypes.get(type)?.tsType,
             nullable: options?.nullable,
             list: list,
             connection: connection,
             isContextArg: metadata.isContextArg,
         };
         // unknown type. we need to flag that this field needs to eventually be resolved
-        if (!GQLCapture.knownAllowedNames.has(type)) {
+        if (!exports.knownAllowedNames.has(type)) {
             if (scalarType) {
                 throw new Error(`custom scalar type ${type} is not supported this way. use CustomType syntax. see \`gqlFileUpload\` as an example`);
             }
@@ -461,22 +478,6 @@ GQLCapture.customArgs = new Map();
 GQLCapture.customInputObjects = new Map();
 GQLCapture.customObjects = new Map();
 GQLCapture.customTypes = new Map();
-GQLCapture.knownAllowedNames = new Map([
-    ["Date", "Date"],
-    ["Boolean", "boolean"],
-    ["Number", "number"],
-    ["String", "string"],
-    // TODO not right to have this and Number
-    ["Int", "number"],
-    ["Float", "number"],
-    ["ID", "ID"],
-]);
-GQLCapture.knownDisAllowedNames = new Map([
-    ["Function", true],
-    ["Object", true],
-    ["Array", true],
-    ["Promise", true],
-]);
 // User -> add -> [{name, options}, {}, {}]
 GQLCapture.argMap = new Map();
 // why is this a static class lol?

package/graphql/node_resolver.d.ts

@@ -5,7 +5,6 @@ interface Node {
     id: ID;
 }
 export interface NodeResolver {
-    encode(node: Node): string;
     decodeObj(viewer: Viewer, id: string): Promise<Node | null>;
 }
 interface loadEnt {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.36",
+  "version": "0.0.39-alpha4",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -17,7 +17,7 @@
     "json5": "^2.1.3",
     "luxon": "^1.25.0",
     "memoizee": "^0.4.15",
-    "minimist": "^1.2.5",
+    "minimist": "^1.2.6",
     "pascal-case": "^3.1.2",
     "pg": "^8.0.3",
     "prettier": "^2.3.2",

package/parse_schema/parse.d.ts

@@ -12,7 +12,13 @@ declare type ProcessedAssocEdge = Omit<AssocEdge, "actionOnlyFields" | "edgeActi
     patternName?: string;
     edgeActions?: OutputAction[];
 };
-declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & {
+interface TransformFlags {
+    transformsSelect?: boolean;
+    transformsDelete?: boolean;
+    transformsInsert?: boolean;
+    transformsUpdate?: boolean;
+}
+declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & TransformFlags & {
     actions: OutputAction[];
     assocEdges: ProcessedAssocEdge[];
     assocEdgeGroups: ProcessedAssocEdgeGroup[];

package/parse_schema/parse.js

@@ -31,10 +31,29 @@ function processFields(src, patternName) {
         if (patternName) {
             f.patternName = patternName;
         }
+        transformType(field.type);
         ret.push(f);
     }
     return ret;
 }
+function transformImportType(typ) {
+    if (!typ.importType) {
+        return;
+    }
+    typ.importType = {
+        ...typ.importType,
+        // these 2 needed for forwards compatibility with new go schema
+        importPath: typ.importType.path,
+        import: typ.importType.type,
+    };
+}
+function transformType(typ) {
+    if (!typ) {
+        return;
+    }
+    transformImportType(typ);
+    transformType(typ.listElemType);
+}
 function processEdges(src, patternName) {
     const ret = [];
     for (const edge of src) {
@@ -59,6 +78,9 @@ function processEdgeGroups(processedSchema, edgeGroups) {
     }
 }
 function processPattern(patterns, pattern, processedSchema) {
+    let ret = {
+        ...pattern,
+    };
     const name = pattern.name;
     const fields = processFields(pattern.fields, pattern.name);
     processedSchema.fields.push(...fields);
@@ -66,6 +88,10 @@ function processPattern(patterns, pattern, processedSchema) {
         const edges = processEdges(pattern.edges, pattern.name);
         processedSchema.assocEdges.push(...edges);
     }
+    // flag transformsSelect
+    if (pattern.transformRead) {
+        ret.transformsSelect = true;
+    }
     if (patterns[name] === undefined) {
         // intentionally processing separately and not passing pattern.name
         const edges = processEdges(pattern.edges || []);
@@ -79,6 +105,7 @@ function processPattern(patterns, pattern, processedSchema) {
         // TODO ideally we want to make sure that different patterns don't have the same name
         // can't do a deepEqual check because function calls and therefore different instances in fields
     }
+    return ret;
 }
 var NullableResult;
 (function (NullableResult) {
@@ -141,7 +168,19 @@ function parseSchema(potentialSchemas) {
         // ¯\_(ツ)_/¯
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
-                processPattern(patterns, pattern, processedSchema);
+                const ret = processPattern(patterns, pattern, processedSchema);
+                if (ret.transformsSelect) {
+                    if (processedSchema.transformsSelect) {
+                        throw new Error(`can only have one pattern which transforms default querying behavior`);
+                    }
+                    processedSchema.transformsSelect = true;
+                }
+                if (ret.transformsDelete) {
+                    if (processedSchema.transformsDelete) {
+                        throw new Error(`can only have one pattern which transforms default deletion behavior`);
+                    }
+                    processedSchema.transformsDelete = true;
+                }
             }
         }
         const fields = processFields(schema.fields);

package/schema/index.d.ts

@@ -1,6 +1,6 @@
 import Schema from "./schema";
 export { Schema };
-export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, ActionOperation, Action, EdgeAction, NoFields, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, } from "./schema";
+export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, ActionOperation, Action, EdgeAction, NoFields, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, getTransformedReadClause, } from "./schema";
 export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, } from "./base_schema";
 export * from "./field";
 export * from "./json_field";

package/schema/index.js

@@ -10,7 +10,7 @@ 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 });
-exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getFields = exports.DBType = void 0;
+exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.getTransformedReadClause = exports.SQLStatementOperation = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getFields = exports.DBType = void 0;
 var schema_1 = require("./schema");
 Object.defineProperty(exports, "DBType", { enumerable: true, get: function () { return schema_1.DBType; } });
 Object.defineProperty(exports, "getFields", { enumerable: true, get: function () { return schema_1.getFields; } });
@@ -19,6 +19,8 @@ Object.defineProperty(exports, "NoFields", { enumerable: true, get: function ()
 Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return schema_1.ConstraintType; } });
 Object.defineProperty(exports, "requiredField", { enumerable: true, get: function () { return schema_1.requiredField; } });
 Object.defineProperty(exports, "optionalField", { enumerable: true, get: function () { return schema_1.optionalField; } });
+Object.defineProperty(exports, "SQLStatementOperation", { enumerable: true, get: function () { return schema_1.SQLStatementOperation; } });
+Object.defineProperty(exports, "getTransformedReadClause", { enumerable: true, get: function () { return schema_1.getTransformedReadClause; } });
 var base_schema_1 = require("./base_schema");
 Object.defineProperty(exports, "Timestamps", { enumerable: true, get: function () { return base_schema_1.Timestamps; } });
 Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return base_schema_1.Node; } });

package/schema/schema.d.ts

@@ -1,5 +1,6 @@
-import { Data, Ent, LoaderInfo } from "../core/base";
+import { Data, Ent, LoaderInfo, Viewer } from "../core/base";
 import { Builder } from "../action/action";
+import { Clause } from "../core/clause";
 export default interface Schema {
     fields: Field[];
     tableName?: string;
@@ -59,6 +60,27 @@ export interface Pattern {
     name: string;
     fields: Field[];
     edges?: Edge[];
+    transformRead?: () => Clause;
+    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | undefined;
+    transformsDelete?: boolean;
+    transformsInsert?: boolean;
+    transformsUpdate?: boolean;
+}
+export declare enum SQLStatementOperation {
+    Insert = "insert",
+    Update = "update",
+    Delete = "delete"
+}
+export interface UpdateOperation<T extends Ent> {
+    op: SQLStatementOperation;
+    existingEnt?: T;
+    viewer: Viewer;
+    data?: Map<string, any>;
+}
+export interface TransformedUpdateOperation<T extends Ent> {
+    op: SQLStatementOperation;
+    data?: Data;
+    existingEnt?: T;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -82,6 +104,7 @@ export declare enum DBType {
 export interface ImportType {
     path: string;
     type: string;
+    [x: string]: any;
 }
 declare type EnumMap = {
     [key: string]: string;
@@ -131,6 +154,7 @@ export interface FieldOptions {
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
     disableUserEditable?: boolean;
+    disableUserGraphQLEditable?: boolean;
     defaultValueOnCreate?(builder: Builder<Ent>, input: Data): any;
     defaultToViewerOnCreate?: boolean;
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
@@ -153,7 +177,10 @@ export interface SchemaConstructor {
     new (): Schema;
 }
 export declare type SchemaInputType = Schema | SchemaConstructor;
+export declare function getSchema(value: SchemaInputType): Schema;
 export declare function getFields(value: SchemaInputType): Map<string, Field>;
+export declare function getTransformedReadClause(value: SchemaInputType): Clause | undefined;
+export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | undefined;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,

package/schema/schema.js

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getFields = exports.DBType = void 0;
+exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getTransformedUpdateOp = exports.getTransformedReadClause = exports.getFields = exports.getSchema = exports.DBType = exports.SQLStatementOperation = void 0;
+// we also want this transformation to exist on a per-action basis
+// if it exists on an action, we don't do the global schema transformation
+var SQLStatementOperation;
+(function (SQLStatementOperation) {
+    // transform insert e.g. to an update based on whatever logic
+    SQLStatementOperation["Insert"] = "insert";
+    // // transform select e.g. deleted_at. can't change from select to different query type
+    // // but can change the query
+    // Select = "select",
+    // e.g. change updated value
+    SQLStatementOperation["Update"] = "update";
+    // delete -> update theoretically e.g. deleted_at
+    SQLStatementOperation["Delete"] = "delete";
+})(SQLStatementOperation = exports.SQLStatementOperation || (exports.SQLStatementOperation = {}));
 // we want --strictNullChecks flag so nullable is used to type graphql, ts, db
 // should eventually generate (boolean | null) etc
 // supported db types
@@ -28,14 +42,17 @@ var DBType;
 function isSchema(value) {
     return value.fields !== undefined;
 }
-function getFields(value) {
-    let schema;
+function getSchema(value) {
     if (isSchema(value)) {
-        schema = value;
+        return value;
     }
     else {
-        schema = new value();
+        return new value();
     }
+}
+exports.getSchema = getSchema;
+function getFields(value) {
+    const schema = getSchema(value);
     function addFields(fields) {
         for (const field of fields) {
             const derivedFields = field.derivedFields;
@@ -55,6 +72,33 @@ function getFields(value) {
     return m;
 }
 exports.getFields = getFields;
+function getTransformedReadClause(value) {
+    const schema = getSchema(value);
+    if (!schema.patterns) {
+        return;
+    }
+    for (const p of schema.patterns) {
+        // e.g. discarded_at, deleted_at, etc
+        if (p.transformRead) {
+            // return clause.Eq('deleted_at', null);
+            return p.transformRead();
+        }
+    }
+    return;
+}
+exports.getTransformedReadClause = getTransformedReadClause;
+function getTransformedUpdateOp(value, stmt) {
+    const schema = getSchema(value);
+    if (!schema.patterns) {
+        return;
+    }
+    for (const p of schema.patterns) {
+        if (p.transformWrite) {
+            return p.transformWrite(stmt);
+        }
+    }
+}
+exports.getTransformedUpdateOp = getTransformedUpdateOp;
 // this maps to ActionOperation in ent/action.go
 var ActionOperation;
 (function (ActionOperation) {

package/scripts/custom_graphql.js

@@ -24,6 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const glob_1 = __importDefault(require("glob"));
+const json5_1 = __importDefault(require("json5"));
 const minimist_1 = __importDefault(require("minimist"));
 const graphql_1 = require("../graphql/graphql");
 const readline = __importStar(require("readline"));
@@ -53,7 +54,103 @@ async function readInputs() {
         });
     });
 }
-async function captureCustom(filePath, filesCsv) {
+function processCustomObjects(l, gqlCapture, input) {
+    let m;
+    if (input) {
+        m = gqlCapture.getCustomInputObjects();
+    }
+    else {
+        m = gqlCapture.getCustomObjects();
+    }
+    for (const input of l) {
+        m.set(input.name, {
+            nodeName: input.graphQLName || input.name,
+            className: input.name,
+        });
+        if (input.fields) {
+            processCustomFields(input.fields, gqlCapture, input.name);
+        }
+    }
+}
+function transformArgs(f) {
+    return (f.args || []).map((v) => {
+        const ret = {
+            ...v,
+        };
+        // duplicated from getType in graphql.ts
+        if ((0, graphql_1.isCustomType)(ret.type)) {
+            ret.type = v.type.type;
+            (0, graphql_1.addCustomType)(v.type);
+        }
+        // scalar types not supported for now
+        ret.tsType = graphql_1.knownAllowedNames.get(v.type);
+        return ret;
+    });
+}
+function transformResultType(f) {
+    return f.resultType
+        ? [
+            {
+                name: "",
+                type: f.resultType,
+                tsType: graphql_1.knownAllowedNames.get(f.resultType),
+                list: f.list,
+                nullable: f.nullable,
+            },
+        ]
+        : [];
+}
+function processTopLevel(l, l2) {
+    for (const custom of l) {
+        l2.push({
+            nodeName: custom.class,
+            functionName: custom.functionName || custom.name,
+            gqlName: custom.graphQLName || custom.name,
+            fieldType: custom.fieldType,
+            args: transformArgs(custom),
+            results: transformResultType(custom),
+        });
+    }
+}
+function processCustomFields(fields, gqlCapture, nodeName) {
+    const m = gqlCapture.getCustomFields();
+    let results = [];
+    for (const f of fields) {
+        results.push({
+            nodeName: nodeName,
+            gqlName: f.graphQLName || f.name,
+            functionName: f.functionName || f.name,
+            fieldType: f.fieldType,
+            args: transformArgs(f),
+            results: transformResultType(f),
+        });
+    }
+    m.set(nodeName, results);
+}
+async function captureCustom(filePath, filesCsv, jsonPath, gqlCapture) {
+    if (jsonPath !== undefined) {
+        let json = json5_1.default.parse(fs.readFileSync(jsonPath, {
+            encoding: "utf8",
+        }));
+        if (json.fields) {
+            for (const k in json.fields) {
+                processCustomFields(json.fields[k], gqlCapture, k);
+            }
+        }
+        if (json.inputs) {
+            processCustomObjects(json.inputs, gqlCapture, true);
+        }
+        if (json.objects) {
+            processCustomObjects(json.objects, gqlCapture);
+        }
+        if (json.queries) {
+            processTopLevel(json.queries, gqlCapture.getCustomQueries());
+        }
+        if (json.mutations) {
+            processTopLevel(json.mutations, gqlCapture.getCustomMutations());
+        }
+        return;
+    }
     if (filesCsv !== undefined) {
         let files = filesCsv.split(",");
         for (let i = 0; i < files.length; i++) {
@@ -153,15 +250,25 @@ async function main() {
     if (!gqlPath) {
         throw new Error("could not find graphql path");
     }
-    const r = require(gqlPath);
-    if (!r.GQLCapture) {
-        throw new Error("could not find GQLCapture in module");
+    // use different variable  so that we use the correct GQLCapture as needed
+    // for local dev, get the one from the file system. otherwise, get the one
+    // from node_modules
+    let gqlCapture;
+    if (process.env.LOCAL_SCRIPT_PATH) {
+        const r = require("../graphql/graphql");
+        gqlCapture = r.GQLCapture;
+    }
+    else {
+        const r = require(gqlPath);
+        if (!r.GQLCapture) {
+            throw new Error("could not find GQLCapture in module");
+        }
+        gqlCapture = r.GQLCapture;
+        gqlCapture.enable(true);
     }
-    const GQLCapture = r.GQLCapture;
-    GQLCapture.enable(true);
     const [inputsRead, _, imports] = await Promise.all([
         readInputs(),
-        captureCustom(options.path, options.files),
+        captureCustom(options.path, options.files, options.json_path, gqlCapture),
         parseImports(options.path),
     ]);
     const { nodes, nodesMap } = inputsRead;
@@ -172,14 +279,14 @@ async function main() {
         }
         return result;
     }
-    GQLCapture.resolve(nodes);
-    let args = fromMap(GQLCapture.getCustomArgs());
-    let inputs = fromMap(GQLCapture.getCustomInputObjects());
-    let fields = GQLCapture.getProcessedCustomFields();
-    let queries = GQLCapture.getProcessedCustomQueries();
-    let mutations = GQLCapture.getProcessedCustomMutations();
-    let objects = fromMap(GQLCapture.getCustomObjects());
-    let customTypes = fromMap(GQLCapture.getCustomTypes());
+    gqlCapture.resolve(nodes);
+    let args = fromMap(gqlCapture.getCustomArgs());
+    let inputs = fromMap(gqlCapture.getCustomInputObjects());
+    let fields = gqlCapture.getProcessedCustomFields();
+    let queries = gqlCapture.getProcessedCustomQueries();
+    let mutations = gqlCapture.getProcessedCustomMutations();
+    let objects = fromMap(gqlCapture.getCustomObjects());
+    let customTypes = fromMap(gqlCapture.getCustomTypes());
     let classes = {};
     let allFiles = {};
     const buildClasses2 = (args) => {

package/testutils/builder.js

@@ -149,6 +149,11 @@ class SimpleBuilder {
             editedFields: () => {
                 return this.fields;
             },
+            updateInput: (input) => {
+                for (const k in input) {
+                    this.fields.set(k, input[k]);
+                }
+            },
         });
     }
     build() {

package/testutils/ent-graphql-tests/index.d.ts

@@ -16,6 +16,8 @@ interface queryConfig {
     callback?: (res: supertest.Response) => void;
     inlineFragmentRoot?: string;
     customHandlers?: RequestHandler[];
+    server?: any;
+    graphQLPath?: string;
 }
 export interface queryRootConfig extends queryConfig {
     root: string;

package/testutils/ent-graphql-tests/index.js

@@ -56,7 +56,7 @@ function server(config) {
         };
         return doWork();
     }));
-    app.use("/graphql", ...handlers);
+    app.use(config.graphQLPath || "/graphql", ...handlers);
     return app;
 }
 function getInnerType(typ, list) {
@@ -72,14 +72,14 @@ function makeGraphQLRequest(config, query, fieldArgs) {
     let test;
     if (config.test) {
         if (typeof config.test === "function") {
-            test = config.test(server(config));
+            test = config.test(config.server ? config.server : server(config));
         }
         else {
             test = config.test;
         }
     }
     else {
-        test = (0, supertest_1.default)(server(config));
+        test = (0, supertest_1.default)(config.server ? config.server : server(config));
     }
     let files = new Map();
     // handle files
@@ -104,7 +104,9 @@ function makeGraphQLRequest(config, query, fieldArgs) {
         }
     });
     if (files.size) {
-        let ret = test.post("/graphql").set(config.headers || {});
+        let ret = test
+            .post(config.graphQLPath || "/graphql")
+            .set(config.headers || {});
         ret.field("operations", JSON.stringify({
             query: query,
             variables: config.args,
@@ -130,7 +132,7 @@ function makeGraphQLRequest(config, query, fieldArgs) {
         return [
             test,
             test
-                .post("/graphql")
+                .post(config.graphQLPath || "/graphql")
                 .set(config.headers || {})
                 .send({
                 query: query,