Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/var/www/html/wincloud_gateway/node_modules/apollo-server-core/dist/utils/   drwxr-xr-x
Free 13.01 GB of 57.97 GB (22.44%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     schemaInstrumentation.js (4.04 KB)      -rw-r--r--

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.whenResultIsFinished = exports.enablePluginsForSchemaResolvers = exports.symbolPluginsEnabled = exports.symbolUserFieldResolver = exports.symbolExecutionDispatcherWillResolveField = void 0;
const type_1 = require("graphql/type");
const execution_1 = require("graphql/execution");
exports.symbolExecutionDispatcherWillResolveField = Symbol("apolloServerExecutionDispatcherWillResolveField");
exports.symbolUserFieldResolver = Symbol("apolloServerUserFieldResolver");
exports.symbolPluginsEnabled = Symbol("apolloServerPluginsEnabled");
function enablePluginsForSchemaResolvers(schema) {
    if (schema[exports.symbolPluginsEnabled]) {
        return schema;
    }
    Object.defineProperty(schema, exports.symbolPluginsEnabled, {
        value: true,
    });
    forEachField(schema, wrapField);
    return schema;
}
exports.enablePluginsForSchemaResolvers = enablePluginsForSchemaResolvers;
function wrapField(field) {
    const originalFieldResolve = field.resolve;
    field.resolve = (source, args, context, info) => {
        const parentPath = info.path.prev;
        const willResolveField = context === null || context === void 0 ? void 0 : context[exports.symbolExecutionDispatcherWillResolveField];
        const userFieldResolver = context === null || context === void 0 ? void 0 : context[exports.symbolUserFieldResolver];
        const didResolveField = typeof willResolveField === 'function' &&
            willResolveField({ source, args, context, info });
        const resolveObject = info.parentType.resolveObject;
        let whenObjectResolved;
        if (parentPath && resolveObject) {
            if (!parentPath.__fields) {
                parentPath.__fields = {};
            }
            parentPath.__fields[info.fieldName] = info.fieldNodes;
            whenObjectResolved = parentPath.__whenObjectResolved;
            if (!whenObjectResolved) {
                whenObjectResolved = Promise.resolve().then(() => {
                    return resolveObject(source, parentPath.__fields, context, info);
                });
                parentPath.__whenObjectResolved = whenObjectResolved;
            }
        }
        const fieldResolver = originalFieldResolve || userFieldResolver || execution_1.defaultFieldResolver;
        try {
            let result;
            if (whenObjectResolved) {
                result = whenObjectResolved.then((resolvedObject) => {
                    return fieldResolver(resolvedObject, args, context, info);
                });
            }
            else {
                result = fieldResolver(source, args, context, info);
            }
            if (typeof didResolveField === "function") {
                whenResultIsFinished(result, didResolveField);
            }
            return result;
        }
        catch (error) {
            if (typeof didResolveField === "function") {
                didResolveField(error);
            }
            throw error;
        }
    };
    ;
}
function isPromise(x) {
    return x && typeof x.then === 'function';
}
function whenResultIsFinished(result, callback) {
    if (isPromise(result)) {
        result.then((r) => callback(null, r), (err) => callback(err));
    }
    else if (Array.isArray(result)) {
        if (result.some(isPromise)) {
            Promise.all(result).then((r) => callback(null, r), (err) => callback(err));
        }
        else {
            callback(null, result);
        }
    }
    else {
        callback(null, result);
    }
}
exports.whenResultIsFinished = whenResultIsFinished;
function forEachField(schema, fn) {
    const typeMap = schema.getTypeMap();
    Object.entries(typeMap).forEach(([typeName, type]) => {
        if (!type_1.getNamedType(type).name.startsWith('__') &&
            type instanceof type_1.GraphQLObjectType) {
            const fields = type.getFields();
            Object.entries(fields).forEach(([fieldName, field]) => {
                fn(field, typeName, fieldName);
            });
        }
    });
}
//# sourceMappingURL=schemaInstrumentation.js.map