@accounter/payper-mesh/dist/esm/mesh-artifacts/index.js

Graphql proxy for Payper API

import { gql } from '@graphql-mesh/utils';
import { handleImport } from '@graphql-mesh/utils';
import { PubSub } from '@graphql-mesh/utils';
import { DefaultLogger } from '@graphql-mesh/utils';
import { parse } from 'graphql';
import { createMeshHTTPHandler } from '@graphql-mesh/http';
import { getMesh } from '@graphql-mesh/runtime';
import { MeshStore, FsStoreStorageAdapter } from '@graphql-mesh/store';
import { path as pathModule } from '@graphql-mesh/cross-helpers';
const baseDir = pathModule.join(typeof __dirname === 'string' ? __dirname : '/', '..');
const importFn = (moduleId) => {
    const relativeModuleId = (pathModule.isAbsolute(moduleId) ? pathModule.relative(baseDir, moduleId) : moduleId).split('\\').join('/').replace(baseDir + '/', '');
    switch (relativeModuleId) {
        case "mesh-artifacts/sources/Payper/schemaWithAnnotations.js":
            return import("./sources/Payper/schemaWithAnnotations.js");
        default:
            return Promise.reject(new Error(`Cannot find module '${relativeModuleId}'.`));
    }
};
const rootStore = new MeshStore('mesh-artifacts', new FsStoreStorageAdapter({
    cwd: baseDir,
    importFn,
    fileType: "js",
}), {
    readonly: true,
    validate: false
});
export const rawServeConfig = { "browser": false };
export async function getMeshOptions() {
    const pubsub = new PubSub();
    const sourcesStore = rootStore.child('sources');
    const logger = new DefaultLogger("");
    const MeshCache = await import("@graphql-mesh/cache-localforage").then(handleImport);
    const cache = new MeshCache({
        ...{},
        importFn,
        store: rootStore.child('cache'),
        pubsub,
        logger,
    });
    const fetchFn = await import('@whatwg-node/fetch').then(m => m?.fetch || m);
    const sources = [];
    const transforms = [];
    const additionalEnvelopPlugins = [];
    const payperTransforms = [];
    const PayperHandler = await import("@graphql-mesh/json-schema").then(handleImport);
    const payperHandler = new PayperHandler({
        name: "Payper",
        config: { "endpoint": "https://payper.co.il/app/api", "operationHeaders": { "API_KEY": "{context.authToken}", "Content-Type": "application/json", "Accept": "application/json" }, "operations": [{ "type": "Query", "field": "getExpensesRaw", "path": "/pull_expenses", "method": "POST", "requestSchema": "./json-schemas/payperSchema.json#/definitions/getExpensesRequest", "responseSchema": "./json-schemas/payperSchema.json#/definitions/getExpensesResponse" }] },
        baseDir,
        cache,
        pubsub,
        store: sourcesStore.child("Payper"),
        logger: logger.child({ source: "Payper" }),
        importFn,
    });
    sources[0] = {
        name: 'Payper',
        handler: payperHandler,
        transforms: payperTransforms
    };
    const additionalTypeDefs = [parse("extend type Query {\n  getExpenses(input: getExpensesRequest_Input): getExpensesResponse\n}"),];
    const additionalResolvers = await Promise.all([
        import("../resolvers/get-expenses-resolver.js")
            .then(m => m.resolvers || m.default || m)
    ]);
    const Merger = await import("@graphql-mesh/merger-bare").then(handleImport);
    const merger = new Merger({
        cache,
        pubsub,
        logger: logger.child({ merger: "bare" }),
        store: rootStore.child("bare")
    });
    return {
        sources,
        transforms,
        additionalTypeDefs,
        additionalResolvers,
        cache,
        pubsub,
        merger,
        logger,
        additionalEnvelopPlugins,
        get documents() {
            return [];
        },
        fetchFn,
    };
}
export function createBuiltMeshHTTPHandler() {
    return createMeshHTTPHandler({
        baseDir,
        getBuiltMesh: getBuiltMesh,
        rawServeConfig: { "browser": false },
    });
}
let meshInstance$;
export const pollingInterval = null;
export function getBuiltMesh() {
    if (meshInstance$ == null) {
        if (pollingInterval) {
            setInterval(() => {
                getMeshOptions()
                    .then(meshOptions => getMesh(meshOptions))
                    .then(newMesh => meshInstance$.then(oldMesh => {
                    oldMesh.destroy();
                    meshInstance$ = Promise.resolve(newMesh);
                })).catch(err => {
                    console.error("Mesh polling failed so the existing version will be used:", err);
                });
            }, pollingInterval);
        }
        meshInstance$ = getMeshOptions().then(meshOptions => getMesh(meshOptions)).then(mesh => {
            const id = mesh.pubsub.subscribe('destroy', () => {
                meshInstance$ = undefined;
                mesh.pubsub.unsubscribe(id);
            });
            return mesh;
        }).catch((err) => {
            meshInstance$ = undefined;
            return Promise.reject(err);
        });
    }
    return meshInstance$;
}
export const execute = (...args) => getBuiltMesh().then(({ execute }) => execute(...args));
export const subscribe = (...args) => getBuiltMesh().then(({ subscribe }) => subscribe(...args));
export function getMeshSDK(globalContext) {
    const sdkRequester$ = getBuiltMesh().then(({ sdkRequesterFactory }) => sdkRequesterFactory(globalContext));
    return getSdk((...args) => sdkRequester$.then(sdkRequester => sdkRequester(...args)));
}
export const getExpensesRaw_queryDocument = gql `
    query getExpensesRaw_query($input: getExpensesRequest_Input) {
  getExpensesRaw(input: $input) {
    description
    expenses {
      created_at
      currency_symbol
      document_date
      document_id
      document_type
      file_name
      file_url
      foreign_total_for_payment
      original_file_name
      provider
      provider_business_num
      recognized_vat_payment
      remarks
      status_classification
      system_id
      total_for_payment
      total_for_vat
      updated_at
      vat_payment
    }
    next_page
    result
    total_entries
    total_pages
  }
}
    `;
export const getExpenses_queryDocument = gql `
    query getExpenses_query($input: getExpensesRequest_Input) {
  getExpenses(input: $input) {
    description
    expenses {
      created_at
      currency_symbol
      document_date
      document_id
      document_type
      file_name
      file_url
      foreign_total_for_payment
      original_file_name
      provider
      provider_business_num
      recognized_vat_payment
      remarks
      status_classification
      system_id
      total_for_payment
      total_for_vat
      updated_at
      vat_payment
    }
    next_page
    result
    total_entries
    total_pages
  }
}
    `;
export function getSdk(requester) {
    return {
        getExpensesRaw_query(variables, options) {
            return requester(getExpensesRaw_queryDocument, variables, options);
        },
        getExpenses_query(variables, options) {
            return requester(getExpenses_queryDocument, variables, options);
        }
    };
}