@orion-js/graphql 3.12.0 → 3.13.1

package/lib/buildSchema/getType/getTypeAsResolver.d.ts

@@ -0,0 +1,10 @@
+export default function ({ resolver, getGraphQLType, options, model }: {
+    resolver: any;
+    getGraphQLType: any;
+    options: any;
+    model: any;
+}): {
+    type: any;
+    args: {};
+    resolve(item: any, params: any, context: any, info: any): Promise<any>;
+};

package/lib/buildSchema/getType/getTypeAsResolver.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getArgs_1 = __importDefault(require("../getArgs"));
+const errorHandler_1 = __importDefault(require("../../errorHandler"));
+function default_1({ resolver, getGraphQLType, options, model }) {
+    const type = getGraphQLType(resolver.returns, options);
+    const args = (0, getArgs_1.default)(resolver.params);
+    return {
+        type,
+        args,
+        async resolve(item, params, context, info) {
+            try {
+                const result = await resolver.resolve(item, params, context, info);
+                return result;
+            }
+            catch (error) {
+                (0, errorHandler_1.default)(error, { context, resolver, options, model });
+                throw error;
+            }
+        },
+    };
+}
+exports.default = default_1;

package/lib/buildSchema/getType/index.d.ts

@@ -0,0 +1,2 @@
+import { StartGraphQLOptions } from '../../types/startGraphQL';
+export default function getGraphQLType(type: any, options: StartGraphQLOptions): any;

package/lib/buildSchema/getType/index.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+const isArray_1 = __importDefault(require("lodash/isArray"));
+const graphql_1 = require("graphql");
+const schema_1 = require("@orion-js/schema");
+const getScalar_1 = __importDefault(require("./getScalar"));
+const getTypeAsResolver_1 = __importDefault(require("./getTypeAsResolver"));
+const getStaticFields_1 = require("../../resolversSchemas/getStaticFields");
+const getDynamicFields_1 = require("../../resolversSchemas/getDynamicFields");
+const getModelLoadedResolvers_1 = require("../../resolversSchemas/getModelLoadedResolvers");
+function getGraphQLType(type, options) {
+    if (!type) {
+        throw new Error('Type is undefined');
+    }
+    if ((0, isArray_1.default)(type)) {
+        const graphQLType = getGraphQLType(type[0], options);
+        return new graphql_1.GraphQLList(graphQLType);
+    }
+    else if (typeof type === 'function' && type.getModel && type.__schemaId) {
+        return getGraphQLType(type.getModel(), options);
+    }
+    else if (!type._isFieldType && ((0, isPlainObject_1.default)(type) || type.__isModel)) {
+        const model = type.__isModel ? type : type.__model;
+        if (!model || !model.__isModel)
+            throw new Error('Type is not a Model');
+        if (model.graphQLType)
+            return model.graphQLType;
+        model.graphQLType = new graphql_1.GraphQLObjectType({
+            name: model.name,
+            fields: () => {
+                const fields = {};
+                for (const field of (0, getStaticFields_1.getStaticFields)(model)) {
+                    try {
+                        /**
+                         * For fields that have custom "to client" resolvers and serverside are static
+                         */
+                        if (field.graphQLResolver) {
+                            fields[field.key] = (0, getTypeAsResolver_1.default)({
+                                resolver: field.graphQLResolver,
+                                getGraphQLType,
+                                options,
+                                model
+                            });
+                        }
+                        else {
+                            fields[field.key] = {
+                                type: getGraphQLType(field.type, options)
+                            };
+                        }
+                    }
+                    catch (error) {
+                        throw new Error(`Error getting type for ${field.key} ${error.message}`);
+                    }
+                }
+                for (const resolver of (0, getDynamicFields_1.getDynamicFields)(model)) {
+                    try {
+                        fields[resolver.key] = (0, getTypeAsResolver_1.default)({ resolver, getGraphQLType, options, model });
+                    }
+                    catch (error) {
+                        throw new Error(`Error getting resolver type for resolver "${resolver.key}": ${error.message}`);
+                    }
+                }
+                for (const resolver of (0, getModelLoadedResolvers_1.getModelLoadedResolvers)(model, options)) {
+                    try {
+                        fields[resolver.key] = (0, getTypeAsResolver_1.default)({ resolver, getGraphQLType, options, model });
+                    }
+                    catch (error) {
+                        throw new Error(`Error getting resolver type for resolver "${resolver.key}": ${error.message}`);
+                    }
+                }
+                return fields;
+            }
+        });
+        return model.graphQLType;
+    }
+    else {
+        const schemaType = (0, schema_1.getFieldType)(type);
+        const graphQLType = (0, getScalar_1.default)(schemaType);
+        return graphQLType;
+    }
+}
+exports.default = getGraphQLType;

package/lib/buildSchema/index.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { StartGraphQLOptions } from '../types/startGraphQL';
+export default function (options: StartGraphQLOptions): Promise<GraphQLSchema>;

package/lib/buildSchema/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const getQuery_1 = __importDefault(require("./getQuery"));
+const getMutation_1 = __importDefault(require("./getMutation"));
+const getSubscription_1 = __importDefault(require("./getSubscription"));
+async function default_1(options) {
+    const query = await (0, getQuery_1.default)(options);
+    const mutation = await (0, getMutation_1.default)(options);
+    const subscription = await (0, getSubscription_1.default)(options);
+    const schema = new graphql_1.GraphQLSchema({ query, mutation, subscription });
+    return schema;
+}
+exports.default = default_1;

package/lib/cleanResolvers.d.ts

@@ -0,0 +1 @@
+export declare const cleanResolvers: () => void;

package/lib/cleanResolvers.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanResolvers = void 0;
+const cleanResolvers = function () {
+    global.graphQLSubscriptions = {};
+    global.graphQLResolvers = {};
+};
+exports.cleanResolvers = cleanResolvers;

package/lib/errorHandler.d.ts

@@ -0,0 +1 @@
+export default function errorHandler(error: any, data: any): void;

package/lib/errorHandler.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const graphql_1 = require("graphql");
+function errorHandler(error, data) {
+    const message = `Error in resolver "${data.name}" ${data.model ? `of model "${data.model.name}"` : ''}`;
+    const hash = crypto_1.default
+        .createHash('sha1')
+        .update(error.message, 'utf8')
+        .digest('hex')
+        .substring(0, 10);
+    error.hash = hash;
+    if (error && error.isOrionError) {
+        console.warn(message, error);
+        throw new graphql_1.GraphQLError(error.message, {
+            originalError: error,
+            extensions: {
+                isOrionError: !!error.isOrionError,
+                isValidationError: !!error.isValidationError,
+                code: error.code,
+                hash,
+                info: error.getInfo()
+            }
+        });
+    }
+    else {
+        console.error(message, error);
+        throw new graphql_1.GraphQLError(`${error.message} [${hash}]`, {
+            // originalError: error,
+            extensions: {
+                isOrionError: false,
+                isValidationError: false,
+                code: 'INTERNAL_SERVER_ERROR',
+                hash: hash
+            }
+        });
+    }
+}
+exports.default = errorHandler;

package/lib/getApolloOptions/formatError.d.ts

@@ -0,0 +1 @@
+export default function (apolloError: any): any;

package/lib/getApolloOptions/formatError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(apolloError) {
+    let response = { ...apolloError };
+    const error = apolloError.originalError;
+    if (error && error.isValidationError) {
+        response.validationErrors = error.validationErrors;
+    }
+    if (error && error.getInfo) {
+        response = error.getInfo();
+    }
+    return response;
+}
+exports.default = default_1;

package/lib/getApolloOptions/index.d.ts

@@ -0,0 +1,3 @@
+import { StartGraphQLOptions } from '../types/startGraphQL';
+import { ApolloServerOptions } from '@apollo/server';
+export default function (options: StartGraphQLOptions): Promise<ApolloServerOptions<any>>;

package/lib/getApolloOptions/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const buildSchema_1 = __importDefault(require("../buildSchema"));
+const formatError_1 = __importDefault(require("./formatError"));
+const lodash_1 = require("lodash");
+async function default_1(options) {
+    const schema = await (0, buildSchema_1.default)(options);
+    const passedOptions = (0, lodash_1.omit)(options, [
+        'resolvers',
+        'modelResolvers',
+        'subscriptions',
+        'executeGraphQLCache',
+        'useGraphiql',
+        'app',
+        'pubsub'
+    ]);
+    return {
+        ...passedOptions,
+        schema,
+        formatError: formatError_1.default
+    };
+}
+exports.default = default_1;

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+import subscription from './subscription';
+import startGraphQL from './startGraphQL';
+import startGraphiQL from './startGraphiQL';
+import resolversSchemas from './resolversSchemas';
+import ResolverParamsInfo from './resolversSchemas/ResolverParamsInfo';
+import serializeSchema from './resolversSchemas/serializeSchema';
+import getBasicResultQuery from './resolversSchemas/getBasicResultQuery';
+import * as GraphQL from 'graphql';
+export { GraphQL, startGraphQL, startGraphiQL, resolversSchemas, ResolverParamsInfo, serializeSchema, subscription, getBasicResultQuery };
+export * from './types';
+export * from './service';
+export * from './websockerViewer';

package/lib/index.js

@@ -0,0 +1,51 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBasicResultQuery = exports.subscription = exports.serializeSchema = exports.ResolverParamsInfo = exports.resolversSchemas = exports.startGraphiQL = exports.startGraphQL = exports.GraphQL = void 0;
+const subscription_1 = __importDefault(require("./subscription"));
+exports.subscription = subscription_1.default;
+const startGraphQL_1 = __importDefault(require("./startGraphQL"));
+exports.startGraphQL = startGraphQL_1.default;
+const startGraphiQL_1 = __importDefault(require("./startGraphiQL"));
+exports.startGraphiQL = startGraphiQL_1.default;
+const resolversSchemas_1 = __importDefault(require("./resolversSchemas"));
+exports.resolversSchemas = resolversSchemas_1.default;
+const ResolverParamsInfo_1 = __importDefault(require("./resolversSchemas/ResolverParamsInfo"));
+exports.ResolverParamsInfo = ResolverParamsInfo_1.default;
+const serializeSchema_1 = __importDefault(require("./resolversSchemas/serializeSchema"));
+exports.serializeSchema = serializeSchema_1.default;
+const getBasicResultQuery_1 = __importDefault(require("./resolversSchemas/getBasicResultQuery"));
+exports.getBasicResultQuery = getBasicResultQuery_1.default;
+const GraphQL = __importStar(require("graphql"));
+exports.GraphQL = GraphQL;
+__exportStar(require("./types"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./websockerViewer"), exports);

package/lib/pubsub.d.ts

@@ -0,0 +1,3 @@
+import { PubSubEngine } from 'graphql-subscriptions';
+export declare const setPubsub: (newPubsub: PubSubEngine) => void;
+export declare const getPubsub: () => PubSubEngine;

package/lib/pubsub.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPubsub = exports.setPubsub = void 0;
+let pubsub = null;
+const setPubsub = function (newPubsub) {
+    pubsub = newPubsub;
+};
+exports.setPubsub = setPubsub;
+const getPubsub = function () {
+    return pubsub;
+};
+exports.getPubsub = getPubsub;

package/lib/resolversSchemas/ResolverParamsInfo.d.ts

@@ -0,0 +1,9 @@
+import { Model } from '@orion-js/models';
+export interface ResolverMetaParam {
+    resolver: {
+        params: any;
+        returns: Model | any;
+    };
+}
+declare const _default: Model<any>;
+export default _default;

package/lib/resolversSchemas/ResolverParamsInfo.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const serializeSchema_1 = __importDefault(require("./serializeSchema"));
+const getBasicResultQuery_1 = __importDefault(require("./getBasicResultQuery"));
+const models_1 = require("@orion-js/models");
+const resolvers_1 = require("@orion-js/resolvers");
+const lodash_1 = require("lodash");
+const resolverReturnsIsModel = (returns) => {
+    return returns && returns.__isModel;
+};
+exports.default = (0, models_1.createModel)({
+    name: 'ResolverParams',
+    schema: {
+        name: {
+            type: String
+        }
+    },
+    resolvers: {
+        params: (0, resolvers_1.resolver)({
+            returns: 'blackbox',
+            resolve: async function ({ resolver }) {
+                return await (0, serializeSchema_1.default)(resolver.params);
+            }
+        }),
+        result: (0, resolvers_1.resolver)({
+            returns: String,
+            resolve: async function ({ resolver }) {
+                const returns = (0, lodash_1.isArray)(resolver.returns) ? resolver.returns[0] : resolver.returns;
+                if (resolverReturnsIsModel(returns))
+                    return returns.name;
+                return;
+            }
+        }),
+        basicResultQuery: (0, resolvers_1.resolver)({
+            returns: String,
+            resolve: async function ({ resolver }) {
+                const returns = (0, lodash_1.isArray)(resolver.returns) ? resolver.returns[0] : resolver.returns;
+                return await (0, getBasicResultQuery_1.default)({
+                    type: resolverReturnsIsModel(returns) ? returns.getSchema() : ''
+                });
+            }
+        })
+    }
+});

package/lib/resolversSchemas/getBasicResultQuery.d.ts

@@ -0,0 +1 @@
+export default function getBasicQuery(field: any): Promise<any>;

package/lib/resolversSchemas/getBasicResultQuery.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isArray_1 = __importDefault(require("lodash/isArray"));
+const getStaticFields_1 = require("./getStaticFields");
+async function getBasicQuery(field) {
+    if (!field.type)
+        return '';
+    if (((0, isArray_1.default)(field.type) && field.type[0].__model) || field.type.__model) {
+        const model = (0, isArray_1.default)(field.type) ? field.type[0].__model : field.type.__model;
+        const fields = [];
+        for (const field of (0, getStaticFields_1.getStaticFields)(model)) {
+            fields.push(await getBasicQuery(field));
+        }
+        const key = field.key ? `${field.key} ` : '';
+        return `${key}{ ${fields.join(' ')} }`;
+    }
+    else {
+        return field.key;
+    }
+}
+exports.default = getBasicQuery;

package/lib/resolversSchemas/getDynamicFields.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '@orion-js/models';
+export declare function getDynamicFields(model: Model): any;

package/lib/resolversSchemas/getDynamicFields.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDynamicFields = void 0;
+function getDynamicFields(model) {
+    const resolvers = model.getResolvers();
+    if (!resolvers)
+        return [];
+    const keys = Object.keys(resolvers);
+    return keys
+        .map(key => {
+        const resolver = resolvers[key];
+        return {
+            ...resolver,
+            key
+        };
+    })
+        .filter(resolver => !resolver.private);
+}
+exports.getDynamicFields = getDynamicFields;

package/lib/resolversSchemas/getField.d.ts

@@ -0,0 +1 @@
+export default function getParams(field: any): any;

package/lib/resolversSchemas/getField.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+const isArray_1 = __importDefault(require("lodash/isArray"));
+const schema_1 = require("@orion-js/schema");
+const omit_1 = __importDefault(require("lodash/omit"));
+const getScalar_1 = __importDefault(require("../buildSchema/getType/getScalar"));
+const getStaticFields_1 = require("./getStaticFields");
+async function getParams(field) {
+    let { type } = field;
+    if (typeof type === 'function' && type.getModel && type.__schemaId) {
+        const model = type.getModel();
+        return await getParams({ ...field, type: model });
+    }
+    else if ((0, isArray_1.default)(type)) {
+        const serialized = await getParams({ ...field, type: type[0] });
+        return {
+            ...serialized,
+            type: [serialized.type],
+            __graphQLType: `[${serialized.__graphQLType}]`
+        };
+    }
+    else if (!type._isFieldType && ((0, isPlainObject_1.default)(type) || type.__isModel)) {
+        const model = type.__isModel ? type : type.__model;
+        if (!model || !model.__isModel)
+            throw new Error('Type is not a Model');
+        const fields = {};
+        for (const field of (0, getStaticFields_1.getStaticFields)(model)) {
+            fields[field.key] = await getParams(field);
+        }
+        return {
+            ...(0, omit_1.default)(field, 'key'),
+            type: fields,
+            __graphQLType: model.name + 'Input'
+        };
+    }
+    else {
+        const schemaType = await (0, schema_1.getFieldType)(type);
+        const graphQLType = await (0, getScalar_1.default)(schemaType);
+        return {
+            ...(0, omit_1.default)(field, 'key'),
+            type: schemaType.name,
+            __graphQLType: graphQLType.name
+        };
+    }
+}
+exports.default = getParams;

package/lib/resolversSchemas/getField.test.d.ts

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

package/lib/resolversSchemas/getField.test.js

@@ -0,0 +1,56 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typed_model_1 = require("@orion-js/typed-model");
+const getField_1 = __importDefault(require("./getField"));
+describe('Field serialization', () => {
+    it('should return a valid serialization of the field', async () => {
+        const schema = {
+            name: {
+                type: String,
+                a: '1234'
+            }
+        };
+        const result = await (0, getField_1.default)(schema.name);
+        expect(result).toEqual({ type: 'string', a: '1234', __graphQLType: 'String' });
+    });
+    it('should pass field options with simple array fields', async () => {
+        const schema = {
+            name: {
+                type: [String],
+                a: '1234'
+            }
+        };
+        const result = await (0, getField_1.default)(schema.name);
+        expect(result.a).toEqual(schema.name.a);
+    });
+    it('Should allow serialization of typed models', async () => {
+        let Point = class Point {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)({ label: 'Name' }),
+            __metadata("design:type", String)
+        ], Point.prototype, "name", void 0);
+        Point = __decorate([
+            (0, typed_model_1.TypedModel)()
+        ], Point);
+        const schema = {
+            point: {
+                type: Point
+            }
+        };
+        const result = await (0, getField_1.default)(schema.point);
+        expect(result.type.name).toEqual({ type: 'string', label: 'Name', __graphQLType: 'String' });
+    });
+});

package/lib/resolversSchemas/getModelLoadedResolvers.d.ts

@@ -0,0 +1,3 @@
+import { Model } from '@orion-js/models';
+import { StartGraphQLOptions } from '../types/startGraphQL';
+export declare function getModelLoadedResolvers(model: Model, options: StartGraphQLOptions): any[];

package/lib/resolversSchemas/getModelLoadedResolvers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelLoadedResolvers = void 0;
+function getModelLoadedResolvers(model, options) {
+    if (!options.modelResolvers)
+        return [];
+    const resolvers = options.modelResolvers[model.name];
+    if (!resolvers)
+        return [];
+    const keys = Object.keys(resolvers);
+    return keys
+        .map(key => {
+        const resolver = resolvers[key];
+        return {
+            ...resolver,
+            key
+        };
+    })
+        .filter(resolver => !resolver.private);
+}
+exports.getModelLoadedResolvers = getModelLoadedResolvers;

package/lib/resolversSchemas/getStaticFields.d.ts

@@ -0,0 +1,3 @@
+import { Model } from '@orion-js/models';
+import { SchemaNode } from '@orion-js/schema';
+export declare function getStaticFields(model: Model): Array<SchemaNode>;

package/lib/resolversSchemas/getStaticFields.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStaticFields = void 0;
+function getStaticFields(model) {
+    const schema = model.getSchema();
+    if (!schema)
+        return [];
+    const keys = Object.keys(schema).filter(key => !key.startsWith('__'));
+    return (keys
+        .map((key) => {
+        const field = schema[key];
+        return {
+            ...field,
+            key
+        };
+    })
+        // there is a compile error if we don't do this
+        .filter(field => !field.private));
+}
+exports.getStaticFields = getStaticFields;

package/lib/resolversSchemas/index.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    params: import("@orion-js/resolvers").Resolver<({ mutation, name }: any, viewer: any) => Promise<{
+        resolver: import("@orion-js/resolvers").Resolver<import("@orion-js/resolvers").GlobalResolverResolve, undefined>;
+        name: any;
+    }>, undefined>;
+};
+export default _default;

package/lib/resolversSchemas/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const params_1 = __importDefault(require("./params"));
+exports.default = {
+    params: params_1.default
+};

package/lib/resolversSchemas/params.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("@orion-js/resolvers").Resolver<({ mutation, name }: any, viewer: any) => Promise<{
+    resolver: import("@orion-js/resolvers").Resolver<import("@orion-js/resolvers").GlobalResolverResolve, undefined>;
+    name: any;
+}>, undefined>;
+export default _default;