@graphql-codegen/plugin-helpers 2.5.0-alpha-252a8d50d.0 → 2.5.0-alpha-2fbcdb6d3.0

package/cjs/errors.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDetailedError = exports.DetailedError = void 0;
+class DetailedError extends Error {
+    constructor(message, details, source) {
+        super(message);
+        this.message = message;
+        this.details = details;
+        this.source = source;
+        Object.setPrototypeOf(this, DetailedError.prototype);
+        Error.captureStackTrace(this, DetailedError);
+    }
+}
+exports.DetailedError = DetailedError;
+function isDetailedError(error) {
+    return error.details;
+}
+exports.isDetailedError = isDetailedError;

package/cjs/federation.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApolloFederation = exports.removeFederation = exports.addFederationReferencesToSchema = exports.federationSpec = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const merge_js_1 = tslib_1.__importDefault(require("lodash/merge.js"));
+const utils_js_1 = require("./utils.js");
+const utils_1 = require("@graphql-tools/utils");
+const index_js_1 = require("./index.js");
+/**
+ * Federation Spec
+ */
+exports.federationSpec = (0, graphql_1.parse)(/* GraphQL */ `
+  scalar _FieldSet
+
+  directive @external on FIELD_DEFINITION
+  directive @requires(fields: _FieldSet!) on FIELD_DEFINITION
+  directive @provides(fields: _FieldSet!) on FIELD_DEFINITION
+  directive @key(fields: _FieldSet!) on OBJECT | INTERFACE
+`);
+/**
+ * Adds `__resolveReference` in each ObjectType involved in Federation.
+ * @param schema
+ */
+function addFederationReferencesToSchema(schema) {
+    return (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.OBJECT_TYPE]: type => {
+            if (isFederationObjectType(type, schema)) {
+                const typeConfig = type.toConfig();
+                typeConfig.fields = {
+                    [resolveReferenceFieldName]: {
+                        type,
+                    },
+                    ...typeConfig.fields,
+                };
+                return new graphql_1.GraphQLObjectType(typeConfig);
+            }
+            return type;
+        },
+    });
+}
+exports.addFederationReferencesToSchema = addFederationReferencesToSchema;
+/**
+ * Removes Federation Spec from GraphQL Schema
+ * @param schema
+ * @param config
+ */
+function removeFederation(schema) {
+    return (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.QUERY]: queryType => {
+            const queryTypeConfig = queryType.toConfig();
+            delete queryTypeConfig.fields._entities;
+            delete queryTypeConfig.fields._service;
+            return new graphql_1.GraphQLObjectType(queryTypeConfig);
+        },
+        [utils_1.MapperKind.UNION_TYPE]: unionType => {
+            const unionTypeName = unionType.name;
+            if (unionTypeName === '_Entity' || unionTypeName === '_Any') {
+                return null;
+            }
+            return unionType;
+        },
+        [utils_1.MapperKind.OBJECT_TYPE]: objectType => {
+            if (objectType.name === '_Service') {
+                return null;
+            }
+            return objectType;
+        },
+    });
+}
+exports.removeFederation = removeFederation;
+const resolveReferenceFieldName = '__resolveReference';
+class ApolloFederation {
+    constructor({ enabled, schema }) {
+        this.enabled = false;
+        this.enabled = enabled;
+        this.schema = schema;
+        this.providesMap = this.createMapOfProvides();
+    }
+    /**
+     * Excludes types definde by Federation
+     * @param typeNames List of type names
+     */
+    filterTypeNames(typeNames) {
+        return this.enabled ? typeNames.filter(t => t !== '_FieldSet') : typeNames;
+    }
+    /**
+     * Excludes `__resolveReference` fields
+     * @param fieldNames List of field names
+     */
+    filterFieldNames(fieldNames) {
+        return this.enabled ? fieldNames.filter(t => t !== resolveReferenceFieldName) : fieldNames;
+    }
+    /**
+     * Decides if directive should not be generated
+     * @param name directive's name
+     */
+    skipDirective(name) {
+        return this.enabled && ['external', 'requires', 'provides', 'key'].includes(name);
+    }
+    /**
+     * Decides if scalar should not be generated
+     * @param name directive's name
+     */
+    skipScalar(name) {
+        return this.enabled && name === '_FieldSet';
+    }
+    /**
+     * Decides if field should not be generated
+     * @param data
+     */
+    skipField({ fieldNode, parentType }) {
+        if (!this.enabled || !(0, graphql_1.isObjectType)(parentType) || !isFederationObjectType(parentType, this.schema)) {
+            return false;
+        }
+        return this.isExternalAndNotProvided(fieldNode, parentType);
+    }
+    isResolveReferenceField(fieldNode) {
+        const name = typeof fieldNode.name === 'string' ? fieldNode.name : fieldNode.name.value;
+        return this.enabled && name === resolveReferenceFieldName;
+    }
+    /**
+     * Transforms ParentType signature in ObjectTypes involved in Federation
+     * @param data
+     */
+    transformParentType({ fieldNode, parentType, parentTypeSignature, }) {
+        if (this.enabled &&
+            (0, graphql_1.isObjectType)(parentType) &&
+            isFederationObjectType(parentType, this.schema) &&
+            (isTypeExtension(parentType, this.schema) || fieldNode.name.value === resolveReferenceFieldName)) {
+            const keys = getDirectivesByName('key', parentType);
+            if (keys.length) {
+                const outputs = [`{ __typename: '${parentType.name}' } &`];
+                // Look for @requires and see what the service needs and gets
+                const requires = getDirectivesByName('requires', fieldNode).map(this.extractKeyOrRequiresFieldSet);
+                const requiredFields = this.translateFieldSet((0, merge_js_1.default)({}, ...requires), parentTypeSignature);
+                // @key() @key() - "primary keys" in Federation
+                const primaryKeys = keys.map(def => {
+                    const fields = this.extractKeyOrRequiresFieldSet(def);
+                    return this.translateFieldSet(fields, parentTypeSignature);
+                });
+                const [open, close] = primaryKeys.length > 1 ? ['(', ')'] : ['', ''];
+                outputs.push([open, primaryKeys.join(' | '), close].join(''));
+                // include required fields
+                if (requires.length) {
+                    outputs.push(`& ${requiredFields}`);
+                }
+                return outputs.join(' ');
+            }
+        }
+        return parentTypeSignature;
+    }
+    isExternalAndNotProvided(fieldNode, objectType) {
+        return this.isExternal(fieldNode) && !this.hasProvides(objectType, fieldNode);
+    }
+    isExternal(node) {
+        return getDirectivesByName('external', node).length > 0;
+    }
+    hasProvides(objectType, node) {
+        const fields = this.providesMap[(0, graphql_1.isObjectType)(objectType) ? objectType.name : objectType.name.value];
+        if (fields && fields.length) {
+            return fields.includes(node.name.value);
+        }
+        return false;
+    }
+    translateFieldSet(fields, parentTypeRef) {
+        return `GraphQLRecursivePick<${parentTypeRef}, ${JSON.stringify(fields)}>`;
+    }
+    extractKeyOrRequiresFieldSet(directive) {
+        const arg = directive.arguments.find(arg => arg.name.value === 'fields');
+        const { value } = arg.value;
+        return (0, index_js_1.oldVisit)((0, graphql_1.parse)(`{${value}}`), {
+            leave: {
+                SelectionSet(node) {
+                    return node.selections.reduce((accum, field) => {
+                        accum[field.name] = field.selection;
+                        return accum;
+                    }, {});
+                },
+                Field(node) {
+                    return {
+                        name: node.name.value,
+                        selection: node.selectionSet ? node.selectionSet : true,
+                    };
+                },
+                Document(node) {
+                    return node.definitions.find((def) => def.kind === 'OperationDefinition' && def.operation === 'query').selectionSet;
+                },
+            },
+        });
+    }
+    extractProvidesFieldSet(directive) {
+        const arg = directive.arguments.find(arg => arg.name.value === 'fields');
+        const { value } = arg.value;
+        if (/[{}]/gi.test(value)) {
+            throw new Error('Nested fields in _FieldSet is not supported in the @provides directive');
+        }
+        return value.split(/\s+/g);
+    }
+    createMapOfProvides() {
+        const providesMap = {};
+        Object.keys(this.schema.getTypeMap()).forEach(typename => {
+            const objectType = this.schema.getType(typename);
+            if ((0, graphql_1.isObjectType)(objectType)) {
+                Object.values(objectType.getFields()).forEach(field => {
+                    const provides = getDirectivesByName('provides', field.astNode)
+                        .map(this.extractProvidesFieldSet)
+                        .reduce((prev, curr) => [...prev, ...curr], []);
+                    const ofType = (0, utils_js_1.getBaseType)(field.type);
+                    if (!providesMap[ofType.name]) {
+                        providesMap[ofType.name] = [];
+                    }
+                    providesMap[ofType.name].push(...provides);
+                });
+            }
+        });
+        return providesMap;
+    }
+}
+exports.ApolloFederation = ApolloFederation;
+/**
+ * Checks if Object Type is involved in Federation. Based on `@key` directive
+ * @param node Type
+ */
+function isFederationObjectType(node, schema) {
+    const { name: { value: name }, directives, } = (0, graphql_1.isObjectType)(node) ? (0, utils_1.astFromObjectType)(node, schema) : node;
+    const rootTypeNames = (0, utils_1.getRootTypeNames)(schema);
+    const isNotRoot = !rootTypeNames.has(name);
+    const isNotIntrospection = !name.startsWith('__');
+    const hasKeyDirective = directives.some(d => d.name.value === 'key');
+    return isNotRoot && isNotIntrospection && hasKeyDirective;
+}
+/**
+ * Extracts directives from a node based on directive's name
+ * @param name directive name
+ * @param node ObjectType or Field
+ */
+function getDirectivesByName(name, node) {
+    var _a;
+    let astNode;
+    if ((0, graphql_1.isObjectType)(node)) {
+        astNode = node.astNode;
+    }
+    else {
+        astNode = node;
+    }
+    return ((_a = astNode === null || astNode === void 0 ? void 0 : astNode.directives) === null || _a === void 0 ? void 0 : _a.filter(d => d.name.value === name)) || [];
+}
+/**
+ * Checks if the Object Type extends a federated type from a remote schema.
+ * Based on if any of its fields contain the `@external` directive
+ * @param node Type
+ */
+function isTypeExtension(node, schema) {
+    var _a;
+    const definition = (0, graphql_1.isObjectType)(node) ? node.astNode || (0, utils_1.astFromObjectType)(node, schema) : node;
+    return (_a = definition.fields) === null || _a === void 0 ? void 0 : _a.some(field => getDirectivesByName('external', field).length);
+}

package/cjs/getCachedDocumentNodeFromSchema.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedDocumentNodeFromSchema = void 0;
+const utils_1 = require("@graphql-tools/utils");
+exports.getCachedDocumentNodeFromSchema = (0, utils_1.memoize1)(utils_1.getDocumentNodeFromSchema);

package/cjs/helpers.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUsingTypes = exports.hasNullableTypeRecursively = exports.normalizeConfig = exports.normalizeInstanceOrArray = exports.normalizeOutputParam = exports.isConfiguredOutput = exports.isOutputConfigArray = void 0;
+const graphql_1 = require("graphql");
+const utils_js_1 = require("./utils.js");
+function isOutputConfigArray(type) {
+    return Array.isArray(type);
+}
+exports.isOutputConfigArray = isOutputConfigArray;
+function isConfiguredOutput(type) {
+    return (typeof type === 'object' && type.plugins) || type.preset;
+}
+exports.isConfiguredOutput = isConfiguredOutput;
+function normalizeOutputParam(config) {
+    // In case of direct array with a list of plugins
+    if (isOutputConfigArray(config)) {
+        return {
+            documents: [],
+            schema: [],
+            plugins: isConfiguredOutput(config) ? config.plugins : config,
+        };
+    }
+    if (isConfiguredOutput(config)) {
+        return config;
+    }
+    throw new Error(`Invalid "generates" config!`);
+}
+exports.normalizeOutputParam = normalizeOutputParam;
+function normalizeInstanceOrArray(type) {
+    if (Array.isArray(type)) {
+        return type;
+    }
+    if (!type) {
+        return [];
+    }
+    return [type];
+}
+exports.normalizeInstanceOrArray = normalizeInstanceOrArray;
+function normalizeConfig(config) {
+    if (typeof config === 'string') {
+        return [{ [config]: {} }];
+    }
+    if (Array.isArray(config)) {
+        return config.map(plugin => (typeof plugin === 'string' ? { [plugin]: {} } : plugin));
+    }
+    if (typeof config === 'object') {
+        return Object.keys(config).reduce((prev, pluginName) => [...prev, { [pluginName]: config[pluginName] }], []);
+    }
+    return [];
+}
+exports.normalizeConfig = normalizeConfig;
+function hasNullableTypeRecursively(type) {
+    if (!(0, graphql_1.isNonNullType)(type)) {
+        return true;
+    }
+    if ((0, graphql_1.isListType)(type) || (0, graphql_1.isNonNullType)(type)) {
+        return hasNullableTypeRecursively(type.ofType);
+    }
+    return false;
+}
+exports.hasNullableTypeRecursively = hasNullableTypeRecursively;
+function isUsingTypes(document, externalFragments, schema) {
+    let foundFields = 0;
+    const typesStack = [];
+    (0, graphql_1.visit)(document, {
+        SelectionSet: {
+            enter(node, key, parent, anscestors) {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                const selections = node.selections || [];
+                if (schema && selections.length > 0) {
+                    const nextTypeName = (() => {
+                        if (parent.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+                            return parent.typeCondition.name.value;
+                        }
+                        if (parent.kind === graphql_1.Kind.FIELD) {
+                            const lastType = typesStack[typesStack.length - 1];
+                            if (!lastType) {
+                                throw new Error(`Unable to find parent type! Please make sure you operation passes validation`);
+                            }
+                            const field = lastType.getFields()[parent.name.value];
+                            if (!field) {
+                                throw new Error(`Unable to find field "${parent.name.value}" on type "${lastType}"!`);
+                            }
+                            return (0, utils_js_1.getBaseType)(field.type).name;
+                        }
+                        if (parent.kind === graphql_1.Kind.OPERATION_DEFINITION) {
+                            if (parent.operation === 'query') {
+                                return schema.getQueryType().name;
+                            }
+                            if (parent.operation === 'mutation') {
+                                return schema.getMutationType().name;
+                            }
+                            if (parent.operation === 'subscription') {
+                                return schema.getSubscriptionType().name;
+                            }
+                        }
+                        else if (parent.kind === graphql_1.Kind.INLINE_FRAGMENT) {
+                            if (parent.typeCondition) {
+                                return parent.typeCondition.name.value;
+                            }
+                            return typesStack[typesStack.length - 1].name;
+                        }
+                        return null;
+                    })();
+                    typesStack.push(schema.getType(nextTypeName));
+                }
+            },
+            leave(node) {
+                const selections = node.selections || [];
+                if (schema && selections.length > 0) {
+                    typesStack.pop();
+                }
+            },
+        },
+        Field: {
+            enter: (node, key, parent, path, anscestors) => {
+                if (node.name.value.startsWith('__')) {
+                    return;
+                }
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                const selections = node.selectionSet ? node.selectionSet.selections || [] : [];
+                const relevantFragmentSpreads = selections.filter(s => s.kind === graphql_1.Kind.FRAGMENT_SPREAD && !externalFragments.includes(s.name.value));
+                if (selections.length === 0 || relevantFragmentSpreads.length > 0) {
+                    foundFields++;
+                }
+                if (schema) {
+                    const lastType = typesStack[typesStack.length - 1];
+                    if (lastType && (0, graphql_1.isObjectType)(lastType)) {
+                        const field = lastType.getFields()[node.name.value];
+                        if (!field) {
+                            throw new Error(`Unable to find field "${node.name.value}" on type "${lastType}"!`);
+                        }
+                        const currentType = field.type;
+                        // To handle `Maybe` usage
+                        if (hasNullableTypeRecursively(currentType)) {
+                            foundFields++;
+                        }
+                    }
+                }
+            },
+        },
+        VariableDefinition: {
+            enter: (node, key, parent, path, anscestors) => {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                foundFields++;
+            },
+        },
+        InputValueDefinition: {
+            enter: (node, key, parent, path, anscestors) => {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                foundFields++;
+            },
+        },
+    });
+    return foundFields > 0;
+}
+exports.isUsingTypes = isUsingTypes;

package/cjs/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExternalModuleAndFn = void 0;
+const tslib_1 = require("tslib");
+var resolve_external_module_and_fn_js_1 = require("./resolve-external-module-and-fn.js");
+Object.defineProperty(exports, "resolveExternalModuleAndFn", { enumerable: true, get: function () { return resolve_external_module_and_fn_js_1.resolveExternalModuleAndFn; } });
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./utils.js"), exports);
+tslib_1.__exportStar(require("./helpers.js"), exports);
+tslib_1.__exportStar(require("./federation.js"), exports);
+tslib_1.__exportStar(require("./errors.js"), exports);
+tslib_1.__exportStar(require("./getCachedDocumentNodeFromSchema.js"), exports);
+tslib_1.__exportStar(require("./oldVisit.js"), exports);
+tslib_1.__exportStar(require("./profiler.js"), exports);

package/cjs/oldVisit.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oldVisit = void 0;
+const graphql_1 = require("graphql");
+function oldVisit(root, { enter: enterVisitors, leave: leaveVisitors, ...newVisitor }) {
+    if (typeof enterVisitors === 'object') {
+        for (const key in enterVisitors) {
+            newVisitor[key] = newVisitor[key] || {};
+            newVisitor[key].enter = enterVisitors[key];
+        }
+    }
+    if (typeof leaveVisitors === 'object') {
+        for (const key in leaveVisitors) {
+            newVisitor[key] = newVisitor[key] || {};
+            newVisitor[key].leave = leaveVisitors[key];
+        }
+    }
+    return (0, graphql_1.visit)(root, newVisitor);
+}
+exports.oldVisit = oldVisit;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/profiler.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProfiler = exports.createNoopProfiler = void 0;
+function createNoopProfiler() {
+    return {
+        run(fn) {
+            return Promise.resolve().then(() => fn());
+        },
+        collect() {
+            return [];
+        },
+    };
+}
+exports.createNoopProfiler = createNoopProfiler;
+function createProfiler() {
+    const events = [];
+    return {
+        collect() {
+            return events;
+        },
+        run(fn, name, cat) {
+            let startTime;
+            return Promise.resolve()
+                .then(() => {
+                startTime = process.hrtime();
+            })
+                .then(() => fn())
+                .then(value => {
+                const duration = process.hrtime(startTime);
+                // Trace Event Format documentation:
+                // https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview
+                const event = {
+                    name,
+                    cat,
+                    ph: 'X',
+                    ts: hrtimeToMicroseconds(startTime),
+                    pid: 1,
+                    tid: 0,
+                    dur: hrtimeToMicroseconds(duration),
+                };
+                events.push(event);
+                return value;
+            });
+        },
+    };
+}
+exports.createProfiler = createProfiler;
+function hrtimeToMicroseconds(hrtime) {
+    return (hrtime[0] * 1e9 + hrtime[1]) / 1000;
+}

package/cjs/resolve-external-module-and-fn.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExternalModuleAndFn = void 0;
+const tslib_1 = require("tslib");
+const module_1 = require("module");
+const process_1 = require("process");
+const changeCaseAll = tslib_1.__importStar(require("change-case-all"));
+function resolveExternalModuleAndFn(pointer) {
+    if (typeof pointer === 'function') {
+        return pointer;
+    }
+    // eslint-disable-next-line prefer-const
+    let [moduleName, functionName] = pointer.split('#');
+    // Temp workaround until v2
+    if (moduleName === 'change-case') {
+        moduleName = 'change-case-all';
+    }
+    let loadedModule;
+    if (moduleName === 'change-case-all') {
+        loadedModule = changeCaseAll;
+    }
+    else {
+        // we have to use a path to a filename here (it does not need to exist.)
+        // https://github.com/dotansimha/graphql-code-generator/issues/6553
+        const cwdRequire = (0, module_1.createRequire)((0, process_1.cwd)() + '/index.js');
+        loadedModule = cwdRequire(moduleName);
+        if (!(functionName in loadedModule) && typeof loadedModule !== 'function') {
+            throw new Error(`${functionName} couldn't be found in module ${moduleName}!`);
+        }
+    }
+    return loadedModule[functionName] || loadedModule;
+}
+exports.resolveExternalModuleAndFn = resolveExternalModuleAndFn;

package/cjs/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isComplexPluginOutput = void 0;
+function isComplexPluginOutput(obj) {
+    return typeof obj === 'object' && obj.hasOwnProperty('content');
+}
+exports.isComplexPluginOutput = isComplexPluginOutput;

package/cjs/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeNonNullWrapper = exports.getBaseType = exports.isWrapperType = exports.mergeOutputs = void 0;
+const graphql_1 = require("graphql");
+function mergeOutputs(content) {
+    const result = { content: '', prepend: [], append: [] };
+    if (Array.isArray(content)) {
+        content.forEach(item => {
+            if (typeof item === 'string') {
+                result.content += item;
+            }
+            else {
+                result.content += item.content;
+                result.prepend.push(...(item.prepend || []));
+                result.append.push(...(item.append || []));
+            }
+        });
+    }
+    return [...result.prepend, result.content, ...result.append].join('\n');
+}
+exports.mergeOutputs = mergeOutputs;
+function isWrapperType(t) {
+    return (0, graphql_1.isListType)(t) || (0, graphql_1.isNonNullType)(t);
+}
+exports.isWrapperType = isWrapperType;
+function getBaseType(type) {
+    if (isWrapperType(type)) {
+        return getBaseType(type.ofType);
+    }
+    return type;
+}
+exports.getBaseType = getBaseType;
+function removeNonNullWrapper(type) {
+    return (0, graphql_1.isNonNullType)(type) ? type.ofType : type;
+}
+exports.removeNonNullWrapper = removeNonNullWrapper;

package/esm/errors.js

@@ -0,0 +1,13 @@
+export class DetailedError extends Error {
+    constructor(message, details, source) {
+        super(message);
+        this.message = message;
+        this.details = details;
+        this.source = source;
+        Object.setPrototypeOf(this, DetailedError.prototype);
+        Error.captureStackTrace(this, DetailedError);
+    }
+}
+export function isDetailedError(error) {
+    return error.details;
+}