@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/graphql/graphql.js

@@ -1,12 +1,7 @@
 "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.isCustomType = exports.knownDisAllowedNames = exports.knownAllowedNames = exports.CustomFieldType = void 0;
-require("reflect-metadata");
-// export interface gqlTopLevelOptions
-//   name?: string;
-//   type?: Type | Array<Type>;
-//   description?: string;
-// }
+exports.gqlFileUpload = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlUnionType = exports.gqlInterfaceType = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlField = exports.GQLCapture = exports.addCustomType = exports.isCustomType = exports.knownInterfaces = exports.knownDisAllowedNames = exports.knownAllowedNames = exports.CustomFieldType = void 0;
+const parse_1 = require("../parse_schema/parse");
 var CustomFieldType;
 (function (CustomFieldType) {
     CustomFieldType["Accessor"] = "ACCESSOR";
@@ -29,6 +24,8 @@ exports.knownAllowedNames = new Map([
     ["Int", "number"],
     ["Float", "number"],
     ["ID", "ID"],
+    ["JSON", "any"],
+    ["Node", "Ent"],
 ]);
 exports.knownDisAllowedNames = new Map([
     ["Function", true],
@@ -36,6 +33,11 @@ exports.knownDisAllowedNames = new Map([
     ["Array", true],
     ["Promise", true],
 ]);
+exports.knownInterfaces = new Map([
+    ["Node", true],
+    ["Edge", true],
+    ["Connection", true],
+]);
 const isArray = (type) => {
     if (typeof type === "function") {
         return false;
@@ -61,13 +63,24 @@ exports.isCustomType = isCustomType;
 const isGraphQLScalarType = (type) => {
     return type.serialize !== undefined;
 };
-const addCustomType = (type) => {
+const addCustomType = async (type, gqlCapture) => {
     // TODO these should return ReadOnly objects...
-    const customTypes = GQLCapture.getCustomTypes();
+    const customTypes = gqlCapture.getCustomTypes();
     const customType = customTypes.get(type.type);
     if (customType && customType === type) {
         return;
     }
+    const addType = async (type) => {
+        // @ts-expect-error
+        const typ2 = { ...type };
+        if (type.structFields) {
+            typ2.structFields = await (0, parse_1.processFields)(type.structFields);
+        }
+        customTypes.set(type.type, typ2);
+    };
+    if (type.enumMap || type.structFields) {
+        await addType(type);
+    }
     try {
         const r = require(type.importPath);
         const ct = r[type.type];
@@ -87,7 +100,7 @@ const addCustomType = (type) => {
             (0, exports.addCustomType)({
                 ...type,
                 importPath: type.secondaryImportPath,
-            });
+            }, gqlCapture);
         }
         return;
     }
@@ -97,7 +110,7 @@ const addCustomType = (type) => {
         }
         return;
     }
-    customTypes.set(type.type, type);
+    await addType(type);
 };
 exports.addCustomType = addCustomType;
 const getType = (typ, result) => {
@@ -121,7 +134,8 @@ const getType = (typ, result) => {
     }
     if ((0, exports.isCustomType)(typ)) {
         result.type = typ.type;
-        (0, exports.addCustomType)(typ);
+        // TODO???
+        (0, exports.addCustomType)(typ, GQLCapture);
         return;
     }
     // GraphQLScalarType or ClassType
@@ -143,8 +157,9 @@ class GQLCapture {
         this.customArgs.clear();
         this.customInputObjects.clear();
         this.customObjects.clear();
+        this.customInterfaces.clear();
+        this.customUnions.clear();
         this.customTypes.clear();
-        this.argMap.clear();
     }
     static getCustomFields() {
         return this.customFields;
@@ -164,6 +179,12 @@ class GQLCapture {
     static getCustomObjects() {
         return this.customObjects;
     }
+    static getCustomInterfaces() {
+        return this.customInterfaces;
+    }
+    static getCustomUnions() {
+        return this.customUnions;
+    }
     static getCustomTypes() {
         return this.customTypes;
     }
@@ -208,33 +229,34 @@ class GQLCapture {
             return res;
         });
     }
-    static getResultFromMetadata(metadata, options) {
-        let type = metadata.name;
-        if ((type === "Number" || type === "Object") && !options?.type) {
-            throw new Error(`type is required when accessor/function/property returns a ${type}`);
-        }
+    static getField(field) {
         let list;
         let scalarType = false;
         let connection;
-        if (options?.type) {
+        let type = "";
+        if (field?.type) {
             let r = { type: "" };
-            getType(options.type, r);
+            getType(field.type, r);
             list = r.list;
             scalarType = r.scalarType || false;
             connection = r.connection;
             type = r.type;
         }
+        if (!type) {
+            throw new Error(`type is required for accessor/function/property`);
+        }
         if (exports.knownDisAllowedNames.has(type)) {
             throw new Error(`${type} isn't a valid type for accessor/function/property`);
         }
         let result = {
-            name: metadata.paramName || "",
-            type,
+            name: field?.name || "",
+            type: type,
             tsType: exports.knownAllowedNames.get(type) || this.customTypes.get(type)?.tsType,
-            nullable: options?.nullable,
+            nullable: field?.nullable,
             list: list,
             connection: connection,
-            isContextArg: metadata.isContextArg,
+            // @ts-ignore
+            isContextArg: field?.isContextArg,
         };
         // unknown type. we need to flag that this field needs to eventually be resolved
         if (!exports.knownAllowedNames.has(type)) {
@@ -246,11 +268,16 @@ class GQLCapture {
         return result;
     }
     static gqlField(options) {
-        return function (target, propertyKey, descriptor) {
-            if (!GQLCapture.isEnabled()) {
+        return function (_target, ctx) {
+            if (!GQLCapture.isEnabled() ||
+                (ctx.kind !== "method" &&
+                    ctx.kind !== "field" &&
+                    ctx.kind !== "getter") ||
+                ctx.static ||
+                ctx.private) {
                 return;
             }
-            let customField = GQLCapture.getCustomField(target, propertyKey, descriptor, options);
+            let customField = GQLCapture.getCustomField(ctx, options);
             if (!customField) {
                 return;
             }
@@ -281,152 +308,109 @@ class GQLCapture {
             GQLCapture.customFields.set(customField.nodeName, list);
         };
     }
-    static getCustomField(target, propertyKey, descriptor, options) {
+    static getCustomField(ctx, options, allowNoReturnType) {
         let fieldType;
-        let nodeName = target.constructor.name;
         let args = [];
         let results = [];
-        let typeMetadata = Reflect.getMetadata("design:type", target, propertyKey);
-        let returnTypeMetadata = Reflect.getMetadata("design:returntype", target, propertyKey);
-        if (returnTypeMetadata) {
-            // function...
-            if (returnTypeMetadata.name === "Promise") {
-                fieldType = CustomFieldType.AsyncFunction;
-            }
-            else {
-                fieldType = CustomFieldType.Function;
-            }
-            results.push(GQLCapture.getResultFromMetadata(returnTypeMetadata, options));
-        }
-        else if (typeMetadata) {
-            if (descriptor && descriptor.get) {
-                fieldType = CustomFieldType.Accessor;
-            }
-            else if (descriptor && descriptor.value) {
-                // could be implicit async
+        switch (ctx.kind) {
+            case "method":
                 fieldType = CustomFieldType.Function;
-            }
-            else {
+                if (options.async) {
+                    fieldType = CustomFieldType.AsyncFunction;
+                }
+                break;
+            case "field":
                 fieldType = CustomFieldType.Field;
-            }
-            if (!(options?.allowFunctionType &&
-                fieldType === CustomFieldType.Function &&
-                typeMetadata.name === "Function")) {
-                results.push(GQLCapture.getResultFromMetadata(typeMetadata, options));
-            }
+                break;
+            case "getter":
+                fieldType = CustomFieldType.Accessor;
+                break;
         }
-        let params = Reflect.getMetadata("design:paramtypes", target, propertyKey);
-        if (params && params.length > 0) {
-            let parsedArgs = GQLCapture.argMap.get(nodeName)?.get(propertyKey) || [];
-            if (params.length !== parsedArgs.length) {
-                throw new Error(`args were not captured correctly, ${params.length}, ${parsedArgs.length}`);
-            }
-            parsedArgs.forEach((arg) => {
-                let param = params[arg.index];
-                let paramName = arg.name;
-                let field = GQLCapture.getResultFromMetadata({
-                    name: param.name,
-                    paramName,
-                    isContextArg: arg.isContextArg,
-                }, arg.options);
-                // TODO this may not be the right order...
-                args.push(field);
+        if (!allowNoReturnType && !options.type) {
+            throw new Error(`type is required for ${fieldType}`);
+        }
+        if (options.type) {
+            // override name property passed down so we return '' as name
+            results.push(GQLCapture.getField({ ...options, name: "" }));
+        }
+        if (options.args?.length) {
+            options.args.forEach((arg) => {
+                args.push(GQLCapture.getField(arg));
             });
-            // TODO this is deterministically (so far) coming in reverse order so reverse (for now)
-            args = args.reverse();
         }
         return {
-            nodeName: nodeName,
-            gqlName: options?.name || propertyKey,
-            functionName: propertyKey,
+            nodeName: options.class,
+            gqlName: options?.name || ctx.name.toString(),
+            functionName: ctx.name.toString(),
             args: args,
             results: results,
             fieldType: fieldType,
             description: options?.description,
         };
     }
-    static argImpl(name, isContextArg, options) {
-        return function (target, propertyKey, index) {
-            if (!GQLCapture.isEnabled()) {
-                return;
-            }
-            let nodeName = target.constructor.name;
-            let m = GQLCapture.argMap.get(nodeName);
-            if (!m) {
-                m = new Map();
-                GQLCapture.argMap.set(nodeName, m);
-            }
-            let propertyMap = m.get(propertyKey);
-            if (!propertyMap) {
-                propertyMap = [];
-                m.set(propertyKey, propertyMap);
-            }
-            propertyMap.push({
-                name: name,
-                index: index,
-                options: options,
-                isContextArg,
-            });
-            //      console.log("arg", name, target, propertyKey, index);
-        };
-    }
-    // TODO custom args because for example name doesn't make sense here.
-    static gqlArg(name, options) {
-        return GQLCapture.argImpl(name, undefined, options);
-    }
     static gqlContextType() {
-        // hardcoded?
-        return GQLCapture.argImpl("context", true, { type: "Context" });
+        return {
+            name: "context",
+            isContextArg: true,
+            type: "Context",
+        };
     }
     static gqlArgType(options) {
-        return function (target, _propertyKey, _descriptor) {
-            return GQLCapture.customGQLObject(target, GQLCapture.customArgs, options);
+        return function (target, ctx) {
+            return GQLCapture.customGQLObject(ctx, GQLCapture.customArgs, options);
         };
     }
     static gqlInputObjectType(options) {
-        return function (target, _propertyKey, _descriptor) {
-            return GQLCapture.customGQLObject(target, GQLCapture.customInputObjects, options);
+        return function (target, ctx) {
+            return GQLCapture.customGQLObject(ctx, GQLCapture.customInputObjects, options);
         };
     }
     static gqlObjectType(options) {
-        return function (target, _propertyKey, _descriptor) {
-            return GQLCapture.customGQLObject(target, GQLCapture.customObjects, options);
+        return function (target, ctx) {
+            return GQLCapture.customGQLObject(ctx, GQLCapture.customObjects, options);
+        };
+    }
+    static gqlUnionType(options) {
+        return function (target, ctx) {
+            return GQLCapture.customGQLObject(ctx, GQLCapture.customUnions, options);
         };
     }
-    static customGQLObject(target, map, options) {
-        if (!GQLCapture.isEnabled()) {
+    static gqlInterfaceType(options) {
+        return function (target, ctx) {
+            return GQLCapture.customGQLObject(ctx, GQLCapture.customInterfaces, options);
+        };
+    }
+    static customGQLObject(ctx, map, options) {
+        if (!GQLCapture.isEnabled() || ctx.kind !== "class" || !ctx.name) {
             return;
         }
-        let className = target.name;
+        let className = ctx.name.toString();
         let nodeName = options?.name || className;
         map.set(className, {
             className,
             nodeName,
             description: options?.description,
+            // @ts-ignore
+            interfaces: options?.interfaces,
+            // @ts-ignore
+            unionTypes: options?.unionTypes,
         });
     }
-    // TODO query and mutation
     // we want to specify args if any, name, response if any
     static gqlQuery(options) {
-        return function (target, propertyKey, descriptor) {
+        return function (target, ctx) {
             if (!GQLCapture.isEnabled()) {
                 return;
             }
-            GQLCapture.customQueries.push(GQLCapture.getCustomField(target, propertyKey, descriptor, options));
+            GQLCapture.customQueries.push(GQLCapture.getCustomField(ctx, options));
         };
     }
-    // we want to specify inputs (required), name, response
-    // input is via gqlArg
-    // should it be gqlInputArg?
     static gqlMutation(options) {
-        return function (target, propertyKey, descriptor) {
+        return function (target, ctx) {
             if (!GQLCapture.isEnabled()) {
                 return;
             }
-            GQLCapture.customMutations.push(GQLCapture.getCustomField(target, propertyKey, descriptor, {
-                ...options,
-                allowFunctionType: true,
-            }));
+            GQLCapture.customMutations.push(GQLCapture.getCustomField(ctx, options, true));
         };
     }
     static gqlConnection(type) {
@@ -436,13 +420,61 @@ class GQLCapture {
     }
     static resolve(objects) {
         let baseObjects = new Map();
-        objects.map((object) => baseObjects.set(object, true));
-        this.customObjects.forEach((_val, key) => baseObjects.set(key, true));
+        objects.forEach((object) => baseObjects.set(object, true));
+        this.customObjects.forEach((obj, key) => {
+            baseObjects.set(key, true);
+            obj.interfaces?.forEach((interfaceName) => {
+                const inter = this.customInterfaces.get(interfaceName);
+                if (inter) {
+                    const fields = this.customFields.get(inter.nodeName);
+                    if (fields) {
+                        // check for duplicate fields
+                        // if field is already defined no need to add it
+                        let objFields = this.customFields.get(obj.nodeName);
+                        if (!objFields) {
+                            objFields = [];
+                        }
+                        let map = new Map();
+                        for (const f of objFields) {
+                            map.set(f.gqlName, f);
+                        }
+                        for (const field of fields) {
+                            const newField = {
+                                ...field,
+                                nodeName: obj.nodeName,
+                            };
+                            if (map.has(field.gqlName)) {
+                                const existing = map.get(field.gqlName);
+                                if (JSON.stringify(existing) !== JSON.stringify(newField)) {
+                                    throw new Error(`object ${obj.nodeName} has duplicate field ${field.gqlName} with different definition`);
+                                }
+                                continue;
+                            }
+                            objFields.push(newField);
+                        }
+                        this.customFields.set(obj.nodeName, objFields);
+                    }
+                }
+                else if (!exports.knownInterfaces.has(interfaceName)) {
+                    throw new Error(`object ${key} references unknown interface ${interfaceName}`);
+                }
+            });
+        });
         let baseArgs = new Map();
         this.customArgs.forEach((_val, key) => baseArgs.set(key, true));
         this.customInputObjects.forEach((_val, key) => baseArgs.set(key, true));
         baseArgs.set("Context", true);
         this.customTypes.forEach((_val, key) => baseArgs.set(key, true));
+        this.customUnions.forEach((val, key) => {
+            if (this.customFields.has(key)) {
+                throw new Error(`union ${key} has custom fields which is not allowed`);
+            }
+            val.unionTypes?.forEach((typ) => {
+                if (!baseObjects.has(typ)) {
+                    throw new Error(`union ${key} references ${typ} which isn't a graphql object`);
+                }
+            });
+        });
         // TODO this should be aware of knownCustomTypes
         const resolveFields = (fields) => {
             fields.forEach((field) => {
@@ -464,7 +496,9 @@ class GQLCapture {
                 // but i don't think it applies
                 field.results.forEach((result) => {
                     if (result.needsResolving) {
-                        if (baseObjects.has(result.type)) {
+                        if (baseObjects.has(result.type) ||
+                            this.customUnions.has(result.type) ||
+                            this.customInterfaces.has(result.type)) {
                             result.needsResolving = false;
                         }
                         else {
@@ -479,7 +513,6 @@ class GQLCapture {
         resolveFields(GQLCapture.customMutations);
     }
 }
-exports.GQLCapture = GQLCapture;
 GQLCapture.enabled = false;
 // map from class name to fields
 GQLCapture.customFields = new Map();
@@ -488,16 +521,18 @@ GQLCapture.customMutations = [];
 GQLCapture.customArgs = new Map();
 GQLCapture.customInputObjects = new Map();
 GQLCapture.customObjects = new Map();
+GQLCapture.customInterfaces = new Map();
+GQLCapture.customUnions = new Map();
 GQLCapture.customTypes = new Map();
-// User -> add -> [{name, options}, {}, {}]
-GQLCapture.argMap = new Map();
+exports.GQLCapture = GQLCapture;
 // why is this a static class lol?
 // TODO make all these just plain functions
 exports.gqlField = GQLCapture.gqlField;
-exports.gqlArg = GQLCapture.gqlArg;
 exports.gqlArgType = GQLCapture.gqlArgType;
 exports.gqlInputObjectType = GQLCapture.gqlInputObjectType;
 exports.gqlObjectType = GQLCapture.gqlObjectType;
+exports.gqlInterfaceType = GQLCapture.gqlInterfaceType;
+exports.gqlUnionType = GQLCapture.gqlUnionType;
 exports.gqlQuery = GQLCapture.gqlQuery;
 exports.gqlMutation = GQLCapture.gqlMutation;
 exports.gqlContextType = GQLCapture.gqlContextType;

package/graphql/graphql_field_helpers.d.ts

@@ -1,4 +1,4 @@
-import { CustomField, Field, CustomObject, CustomMutation, CustomQuery, CustomType } from "./graphql";
+import { CustomField, Field, CustomObject, CustomMutation, CustomQuery, CustomTypeInput } from "./graphql";
 export declare function validateOneCustomField(expected: CustomField): void;
 export declare function validateCustomFields(expected: CustomField[]): void;
 export declare function validateCustomMutations(expected: CustomMutation[]): void;
@@ -8,12 +8,16 @@ export declare function validateNoCustomFields(): void;
 export declare function validateCustomArgs(expected: CustomObject[]): void;
 export declare function validateCustomInputObjects(expected: CustomObject[]): void;
 export declare function validateCustomObjects(expected: CustomObject[]): void;
+export declare function validateCustomInterfaces(expected: CustomObject[]): void;
+export declare function validateCustomUnions(expected: CustomObject[]): void;
 export declare function validateNoCustomArgs(): void;
 export declare function validateNoCustomQueries(): void;
 export declare function validateNoCustomMutations(): void;
 export declare function validateNoCustomInputObjects(): void;
 export declare function validateNoCustomObjects(): void;
 export declare function validateNoCustomTypes(): void;
+export declare function validateNoCustomInterfaces(): void;
+export declare function validateNoCustomUnions(): void;
 export declare enum CustomObjectTypes {
     Field = 1,
     Arg = 2,
@@ -21,7 +25,9 @@ export declare enum CustomObjectTypes {
     InputObject = 8,
     Query = 16,
     Mutation = 32,
-    CustomTypes = 64
+    CustomTypes = 64,
+    Interface = 128,
+    Union = 256
 }
 export declare function validateNoCustom(...exceptions: number[]): void;
-export declare function validateCustomTypes(expected: CustomType[]): void;
+export declare function validateCustomTypes(expected: CustomTypeInput[]): void;

package/graphql/graphql_field_helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateCustomTypes = exports.validateNoCustom = exports.CustomObjectTypes = exports.validateNoCustomTypes = exports.validateNoCustomObjects = exports.validateNoCustomInputObjects = exports.validateNoCustomMutations = exports.validateNoCustomQueries = exports.validateNoCustomArgs = exports.validateCustomObjects = exports.validateCustomInputObjects = exports.validateCustomArgs = exports.validateNoCustomFields = exports.validateFields = exports.validateCustomQueries = exports.validateCustomMutations = exports.validateCustomFields = exports.validateOneCustomField = void 0;
+exports.validateCustomTypes = exports.validateNoCustom = exports.CustomObjectTypes = exports.validateNoCustomUnions = exports.validateNoCustomInterfaces = exports.validateNoCustomTypes = exports.validateNoCustomObjects = exports.validateNoCustomInputObjects = exports.validateNoCustomMutations = exports.validateNoCustomQueries = exports.validateNoCustomArgs = exports.validateCustomUnions = exports.validateCustomInterfaces = exports.validateCustomObjects = exports.validateCustomInputObjects = exports.validateCustomArgs = exports.validateNoCustomFields = exports.validateFields = exports.validateCustomQueries = exports.validateCustomMutations = exports.validateCustomFields = exports.validateOneCustomField = void 0;
 const graphql_1 = require("./graphql");
 function validateOneCustomField(expected) {
     let customFields = graphql_1.GQLCapture.getCustomFields();
@@ -101,6 +101,14 @@ function validateCustomObjects(expected) {
     validateCustom(expected, graphql_1.GQLCapture.getCustomObjects());
 }
 exports.validateCustomObjects = validateCustomObjects;
+function validateCustomInterfaces(expected) {
+    validateCustom(expected, graphql_1.GQLCapture.getCustomInterfaces());
+}
+exports.validateCustomInterfaces = validateCustomInterfaces;
+function validateCustomUnions(expected) {
+    validateCustom(expected, graphql_1.GQLCapture.getCustomUnions());
+}
+exports.validateCustomUnions = validateCustomUnions;
 function validateNoCustomArgs() {
     expect(graphql_1.GQLCapture.getCustomArgs().size).toBe(0);
 }
@@ -125,6 +133,14 @@ function validateNoCustomTypes() {
     expect(graphql_1.GQLCapture.getCustomTypes().size).toBe(0);
 }
 exports.validateNoCustomTypes = validateNoCustomTypes;
+function validateNoCustomInterfaces() {
+    expect(graphql_1.GQLCapture.getCustomInterfaces().size).toBe(0);
+}
+exports.validateNoCustomInterfaces = validateNoCustomInterfaces;
+function validateNoCustomUnions() {
+    expect(graphql_1.GQLCapture.getCustomUnions().size).toBe(0);
+}
+exports.validateNoCustomUnions = validateNoCustomUnions;
 var CustomObjectTypes;
 (function (CustomObjectTypes) {
     CustomObjectTypes[CustomObjectTypes["Field"] = 1] = "Field";
@@ -134,8 +150,10 @@ var CustomObjectTypes;
     CustomObjectTypes[CustomObjectTypes["Query"] = 16] = "Query";
     CustomObjectTypes[CustomObjectTypes["Mutation"] = 32] = "Mutation";
     CustomObjectTypes[CustomObjectTypes["CustomTypes"] = 64] = "CustomTypes";
+    CustomObjectTypes[CustomObjectTypes["Interface"] = 128] = "Interface";
+    CustomObjectTypes[CustomObjectTypes["Union"] = 256] = "Union";
 })(CustomObjectTypes = exports.CustomObjectTypes || (exports.CustomObjectTypes = {}));
-// TODO what's a good name for this instead
+// what's a good name for this instead?
 function validateNoCustom(...exceptions) {
     let bit = 0;
     exceptions.forEach((exp) => (bit = bit | exp));
@@ -151,6 +169,8 @@ function validateNoCustom(...exceptions) {
     validate(CustomObjectTypes.Mutation, validateNoCustomMutations);
     validate(CustomObjectTypes.InputObject, validateNoCustomInputObjects);
     validate(CustomObjectTypes.CustomTypes, validateNoCustomTypes);
+    validate(CustomObjectTypes.Interface, validateNoCustomInterfaces);
+    validate(CustomObjectTypes.Union, validateNoCustomUnions);
 }
 exports.validateNoCustom = validateNoCustom;
 function validateCustomTypes(expected) {

package/graphql/index.d.ts

@@ -1,5 +1,6 @@
-export { gqlFieldOptions, gqlObjectOptions, gqlField, gqlArg, gqlArgType, gqlInputObjectType, gqlObjectType, gqlQuery, gqlMutation, gqlContextType, gqlConnection, GraphQLConnection, GQLCapture, gqlFileUpload, CustomType, } from "./graphql";
+export { gqlFieldOptions, gqlObjectOptions, gqlField, gqlArgType, gqlInputObjectType, gqlObjectType, gqlQuery, gqlMutation, gqlContextType, gqlConnection, GraphQLConnection, GQLCapture, gqlFileUpload, CustomType, gqlInterfaceType, gqlUnionType, } from "./graphql";
 export { GraphQLTime } from "./scalars/time";
+export { GraphQLOrderByDirection } from "./scalars/orderby_direction";
 export { GraphQLPageInfo } from "./query/page_info";
 export { GraphQLEdge, GraphQLEdgeConnection } from "./query/edge_connection";
 export { GraphQLEdgeType, GraphQLConnectionType, } from "./query/connection_type";

package/graphql/index.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformUnionTypes = exports.encodeGQLID = exports.mustDecodeNullableIDFromGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = exports.GraphQLEdgeInterface = exports.GraphQLConnectionInterface = exports.GraphQLNodeInterface = exports.GraphQLConnectionType = exports.GraphQLEdgeType = exports.GraphQLEdgeConnection = exports.GraphQLPageInfo = exports.GraphQLTime = exports.gqlFileUpload = exports.GQLCapture = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlArg = exports.gqlField = void 0;
+exports.transformUnionTypes = exports.encodeGQLID = exports.mustDecodeNullableIDFromGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = exports.GraphQLEdgeInterface = exports.GraphQLConnectionInterface = exports.GraphQLNodeInterface = exports.GraphQLConnectionType = exports.GraphQLEdgeType = exports.GraphQLEdgeConnection = exports.GraphQLPageInfo = exports.GraphQLOrderByDirection = exports.GraphQLTime = exports.gqlUnionType = exports.gqlInterfaceType = exports.gqlFileUpload = exports.GQLCapture = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlField = void 0;
 var graphql_1 = require("./graphql");
 Object.defineProperty(exports, "gqlField", { enumerable: true, get: function () { return graphql_1.gqlField; } });
-Object.defineProperty(exports, "gqlArg", { enumerable: true, get: function () { return graphql_1.gqlArg; } });
 Object.defineProperty(exports, "gqlArgType", { enumerable: true, get: function () { return graphql_1.gqlArgType; } });
 Object.defineProperty(exports, "gqlInputObjectType", { enumerable: true, get: function () { return graphql_1.gqlInputObjectType; } });
 Object.defineProperty(exports, "gqlObjectType", { enumerable: true, get: function () { return graphql_1.gqlObjectType; } });
@@ -13,8 +12,12 @@ Object.defineProperty(exports, "gqlContextType", { enumerable: true, get: functi
 Object.defineProperty(exports, "gqlConnection", { enumerable: true, get: function () { return graphql_1.gqlConnection; } });
 Object.defineProperty(exports, "GQLCapture", { enumerable: true, get: function () { return graphql_1.GQLCapture; } });
 Object.defineProperty(exports, "gqlFileUpload", { enumerable: true, get: function () { return graphql_1.gqlFileUpload; } });
+Object.defineProperty(exports, "gqlInterfaceType", { enumerable: true, get: function () { return graphql_1.gqlInterfaceType; } });
+Object.defineProperty(exports, "gqlUnionType", { enumerable: true, get: function () { return graphql_1.gqlUnionType; } });
 var time_1 = require("./scalars/time");
 Object.defineProperty(exports, "GraphQLTime", { enumerable: true, get: function () { return time_1.GraphQLTime; } });
+var orderby_direction_1 = require("./scalars/orderby_direction");
+Object.defineProperty(exports, "GraphQLOrderByDirection", { enumerable: true, get: function () { return orderby_direction_1.GraphQLOrderByDirection; } });
 var page_info_1 = require("./query/page_info");
 Object.defineProperty(exports, "GraphQLPageInfo", { enumerable: true, get: function () { return page_info_1.GraphQLPageInfo; } });
 var edge_connection_1 = require("./query/edge_connection");

package/graphql/scalars/orderby_direction.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLEnumType } from "graphql";
+export declare const GraphQLOrderByDirection: GraphQLEnumType;

package/graphql/scalars/orderby_direction.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLOrderByDirection = void 0;
+const graphql_1 = require("graphql");
+exports.GraphQLOrderByDirection = new graphql_1.GraphQLEnumType({
+    name: "OrderByDirection",
+    values: {
+        ASC: {
+            value: "ASC",
+        },
+        DESC: {
+            value: "DESC",
+        },
+    },
+});