@factorialco/fcode-cli 1.1.0

package/dist/services/fcode-graphql-client.js

@@ -0,0 +1,721 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_request_1 = require("graphql-request");
+const types_1 = require("../core/types");
+const _ = require("lodash");
+// Shared process selection so pull queries and push mutations return the same
+// fields, keeping mapProcess (and therefore contentHash) consistent.
+const PROCESS_FIELDS = `
+  id
+  slug
+  name
+  description
+  tags
+  resolvingTeamSlug
+  script {
+    parametersSchema
+    sourceCode
+    programmingLanguage
+  }
+  readme
+  triggers {
+    webhook {
+      enabled
+      auth {
+        basicAuth {
+          username
+          password
+          expression {
+            username
+            password
+          }
+        }
+      }
+    }
+  }
+  manifest {
+    dependencies {
+      name
+      semVer
+      gitUrl
+    }
+  }
+  settings {
+    formSettings {
+      enabled
+    }
+    publicationConfig {
+      isPublic
+    }
+    dependencies {
+      scopedToProcess
+    }
+  }
+`;
+const NETWORK_ERROR_CODES = ['ECONNREFUSED', 'ENOTFOUND', 'ECONNRESET', 'ETIMEDOUT', 'EAI_AGAIN'];
+class FcodeGraphQLClient {
+    constructor(options) {
+        if (!options.url) {
+            throw new Error('FcodeGraphQLClient needs the url.');
+        }
+        if (!options.accessToken) {
+            throw new Error('FcodeGraphQLClient needs the accessToken to authenticate.');
+        }
+        this.teamSlug = options.teamSlug;
+        this.url = options.url;
+        this.client = new graphql_request_1.GraphQLClient(`${options.url}/api/graphql`, {
+            headers: {
+                'Fcode-Team': options.teamSlug,
+                authorization: `Bearer ${options.accessToken}`,
+            },
+        });
+    }
+    isDuplicatedError(error) {
+        return (error &&
+            error.response &&
+            error.response.errors &&
+            error.response.errors[0] &&
+            error.response.errors[0].message &&
+            error.response.errors[0].message.includes('Duplicated value'));
+    }
+    isEmptyValueError(error) {
+        return (error &&
+            error.response &&
+            error.response.errors &&
+            error.response.errors[0] &&
+            (error.response.errors[0].message == 'Value cannot be blank' || error.response.errors[0].message.includes('has coerced Null value for NonNull type')));
+    }
+    cleanError(error) {
+        // GraphQL-level errors carry a server message we can surface directly.
+        const graphqlMessage = error?.response?.errors?.[0]?.message;
+        if (graphqlMessage) {
+            return new Error(graphqlMessage);
+        }
+        // HTTP-level failures (bad gateway, service unavailable, server error) have no
+        // GraphQL errors array, so graphql-request dumps the whole query + response into
+        // error.message. Replace that with a short, actionable message.
+        const status = error?.response?.status;
+        if (typeof status === 'number' && status >= 500) {
+            return new Error(this.cloudUnavailableMessage(status));
+        }
+        // Network-level failures (cloud down/unreachable) reject before any response.
+        if (this.isNetworkError(error)) {
+            return new Error(`Could not reach the Factorial Code cloud at ${this.url}. Check that it is running and reachable.`);
+        }
+        return error;
+    }
+    cloudUnavailableMessage(status) {
+        const reason = status === 502 || status === 503 || status === 504 ? 'is temporarily unavailable' : 'returned a server error';
+        return `The Factorial Code cloud at ${this.url} ${reason} (HTTP ${status}). Please try again in a few moments.`;
+    }
+    isNetworkError(error) {
+        if (error?.response) {
+            return false;
+        }
+        if (typeof error?.code === 'string' && NETWORK_ERROR_CODES.includes(error.code)) {
+            return true;
+        }
+        const message = typeof error?.message === 'string' ? error.message : '';
+        return NETWORK_ERROR_CODES.some((code) => message.includes(code)) || message.includes('fetch failed');
+    }
+    allProcesses() {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query processes($first: Int!, $after: String) {
+            processes(first: $first, after: $after) {
+              edges {
+                node {
+                  ${PROCESS_FIELDS}
+                }
+              }
+            }
+          }
+        `, {
+            after: null,
+            first: 200,
+        })
+            .then(({ processes: { edges } }) => edges.map(({ node: process }) => this.mapProcess(process)))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    allVersionedProcesses(processId) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query allVersionedProcesses($processId: ID!) {
+            allVersionedProcesses(processId: $processId) {
+              id
+              tag
+              readme
+              script {
+                parametersSchema
+                programmingLanguage
+                sourceCode
+              }
+            }
+          }
+        `, {
+            processId,
+        })
+            .then(({ allVersionedProcesses }) => allVersionedProcesses.map(({ id, tag, readme, script }) => new types_1.VersionedProcess(id, tag, script, readme)))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    createVersionedProcesses(versionedProcess) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation publishProcess($processId: ID!, $tag: String!, $sourceCode: String, $parametersSchema: JSON, $readme: String) {
+            publishProcess(processId: $processId, tag: $tag, input: { sourceCode: $sourceCode, parametersSchema: $parametersSchema, readme: $readme }) {
+              id
+            }
+          }
+        `, {
+            processId: versionedProcess.id,
+            tag: versionedProcess.tag,
+            parametersSchema: versionedProcess.script.parametersSchema,
+            readme: versionedProcess.readme,
+            sourceCode: versionedProcess.script.sourceCode,
+        })
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    allScriptLibraries() {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query scriptLibraries($first: Int!, $after: String) {
+            scriptLibraries(first: $first, after: $after) {
+              edges {
+                node {
+                  id
+                  name
+                  sourceCode
+                  programmingLanguage
+                  resolvingTeamSlug
+                }
+              }
+            }
+          }
+        `, {
+            after: null,
+            first: 200,
+        })
+            .then(({ scriptLibraries: { edges } }) => edges.map(({ node: { id, name, programmingLanguage, sourceCode, resolvingTeamSlug } }) => new types_1.ScriptLibrary(id, name, sourceCode || '', programmingLanguage, this.inheritedTeam(resolvingTeamSlug))))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    allVersionedScriptLibraries(scriptLibraryId) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query allVersionedScriptLibraries($scriptLibraryId: ID!) {
+            allVersionedScriptLibraries(scriptLibraryId: $scriptLibraryId) {
+              id
+              tag
+              programmingLanguage
+              sourceCode
+            }
+          }
+        `, {
+            scriptLibraryId,
+        })
+            .then(({ allVersionedScriptLibraries }) => allVersionedScriptLibraries.map(({ id, tag, sourceCode, programmingLanguage }) => new types_1.VersionedScriptLibrary(id, tag, sourceCode, programmingLanguage)))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    createVersionedScriptLibrary(versionedScriptLibrary) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation publishScriptLibrary($scriptLibraryId: ID!, $tag: String!, $sourceCode: String) {
+            publishScriptLibrary(scriptLibraryId: $scriptLibraryId, tag: $tag, input: { sourceCode: $sourceCode }) {
+              id
+            }
+          }
+        `, {
+            scriptLibraryId: versionedScriptLibrary.id,
+            tag: versionedScriptLibrary.tag,
+            sourceCode: versionedScriptLibrary.sourceCode,
+        })
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    allVariables() {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query teamVariables($first: Int!, $after: String) {
+            teamVariables(first: $first, after: $after) {
+              edges {
+                node {
+                  id
+                  key
+                  value
+                  isSensitive
+                }
+              }
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+            }
+          }
+        `, {
+            after: null,
+            first: 200,
+        })
+            .then(({ teamVariables: { edges } }) => edges.map(({ node: { id, isSensitive, key, value } }) => new types_1.Variable(id, key, value, isSensitive)))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    toProcessInput(process, includeCreateOnly) {
+        const settings = {
+            dependencies: { scopedToProcess: process.settings.dependencies.scopedToProcess },
+        };
+        if (process.form) {
+            settings.formSettings = { enabled: process.form.enabled };
+        }
+        if (process.visibility) {
+            settings.publicationConfig = { isPublic: process.visibility.isPublic };
+        }
+        const input = {
+            name: process.name,
+            parametersSchema: process.script.parametersSchema,
+            readme: process.readme,
+            tags: process.tags,
+            sourceCode: process.script.sourceCode,
+            manifest: process.settings.dependencies.scopedToProcess ? process.manifest : null,
+            settings,
+        };
+        if (process.description !== undefined) {
+            input.description = process.description;
+        }
+        if (process.webhook) {
+            const webhook = { enabled: process.webhook.enabled };
+            if (process.webhook.username !== undefined) {
+                webhook.username = process.webhook.username;
+            }
+            if (process.webhook.password !== undefined) {
+                webhook.password = process.webhook.password;
+            }
+            input.webhook = webhook;
+        }
+        if (includeCreateOnly) {
+            input.slug = process.slug;
+            input.programmingLanguage = process.script.programmingLanguage;
+        }
+        return input;
+    }
+    pushProcess(process) {
+        if (process.id) {
+            return this.client
+                .request((0, graphql_request_1.gql) `
+            mutation updateProcess($id: ID!, $input: ProcessInput!) {
+              updateProcess(id: $id, input: $input) {
+                ${PROCESS_FIELDS}
+              }
+            }
+          `, {
+                id: process.id,
+                input: this.toProcessInput(process, false),
+            })
+                .then(({ updateProcess: process }) => this.mapProcess(process))
+                .catch((error) => {
+                return Promise.reject(this.cleanError(error));
+            });
+        }
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation createProcess($input: ProcessInput!) {
+            createProcess(input: $input) {
+              ${PROCESS_FIELDS}
+            }
+          }
+        `, {
+            input: this.toProcessInput(process, true),
+        })
+            .then(({ createProcess: process }) => this.mapProcess(process))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    removeProcess(id) {
+        if (!id) {
+            return Promise.reject(new Error('id is required during remove'));
+        }
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation deleteProcess($id: ID!) {
+            deleteProcess(id: $id) {
+              id
+            }
+          }
+        `, {
+            id,
+        })
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    pushScriptLibrary(scriptLibrary) {
+        if (scriptLibrary.id) {
+            return this.client
+                .request((0, graphql_request_1.gql) `
+            mutation updateScriptLibrary($id: ID!, $sourceCode: String) {
+              updateScriptLibrary(id: $id, input: { sourceCode: $sourceCode }) {
+                id
+                name
+                programmingLanguage
+                sourceCode
+              }
+            }
+          `, {
+                id: scriptLibrary.id,
+                sourceCode: scriptLibrary.sourceCode,
+            })
+                .then(({ updateScriptLibrary: scriptLibrary }) => new types_1.ScriptLibrary(scriptLibrary.id, scriptLibrary.name, scriptLibrary.sourceCode, scriptLibrary.programmingLanguage))
+                .catch((error) => {
+                return Promise.reject(this.cleanError(error));
+            });
+        }
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation createScriptLibrary($name: String!, $sourceCode: String, $programmingLanguage: ProgrammingLanguage) {
+            createScriptLibrary(name: $name, programmingLanguage: $programmingLanguage, sourceCode: $sourceCode) {
+              id
+              name
+              sourceCode
+              programmingLanguage
+            }
+          }
+        `, {
+            name: scriptLibrary.name,
+            sourceCode: scriptLibrary.sourceCode,
+            programmingLanguage: scriptLibrary.programmingLanguage,
+        })
+            .then(({ createScriptLibrary: scriptLibrary }) => new types_1.ScriptLibrary(scriptLibrary.id, scriptLibrary.name, scriptLibrary.sourceCode, scriptLibrary.programmingLanguage))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    removeScriptLibrary(id) {
+        if (!id) {
+            return Promise.reject(new Error('id is required during remove'));
+        }
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation deleteScriptLibrary($id: ID!) {
+            deleteScriptLibrary(id: $id) {
+              id
+            }
+          }
+        `, {
+            id,
+        })
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    pushVariable(variable) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation createTeamVariable($key: String!, $value: String!, $isSensitive: Boolean!) {
+            createTeamVariable(key: $key, value: $value, isSensitive: $isSensitive) {
+              id
+              key
+              value
+              isSensitive
+            }
+          }
+        `, {
+            key: variable.key,
+            value: variable.value,
+            isSensitive: variable.isSensitive,
+        })
+            .then(({ createTeamVariable: variable }) => new types_1.Variable(variable.id, variable.key, variable.value, variable.isSensitive))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    updateVariable(variable) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation updateTeamVariable($id: ID!, $key: String, $value: String) {
+            updateTeamVariable(id: $id, key: $key, value: $value) {
+              id
+              key
+              value
+            }
+          }
+        `, {
+            id: variable.id,
+            key: variable.key,
+            value: variable.value,
+        })
+            .then(({ updateTeamVariable: updated }) => new types_1.Variable(updated.id, updated.key, updated.value, variable.isSensitive))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    removeVariable(id) {
+        if (!id) {
+            return Promise.reject(new Error('id is required during remove'));
+        }
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation deleteTeamVariable($id: ID!) {
+            deleteTeamVariable(id: $id) {
+              id
+            }
+          }
+        `, {
+            id,
+        })
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    programmingLanguageManifest(programmingLanguage) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query getProgrammingLanguageManifest($programmingLanguage: ProgrammingLanguage!) {
+            programmingLanguageManifest(programmingLanguage: $programmingLanguage) {
+              id
+              programmingLanguage
+              dependencies {
+                name
+                semVer
+                isNative
+                gitUrl
+              }
+            }
+          }
+        `, { programmingLanguage })
+            .then(({ programmingLanguageManifest }) => {
+            return this.mapProgrammingLanguageManifest(programmingLanguageManifest);
+        })
+            .catch((error) => {
+            // TODO: This is a workaround backward compatibility with old versions of fcode-api.
+            // Remove when full on-premises installations are updated.
+            if (error.response && error.response.errors && error.response.errors[0] && error.response.errors[0].message.includes('isNative')) {
+                return this.client
+                    .request((0, graphql_request_1.gql) `
+                query getProgrammingLanguageManifest($programmingLanguage: ProgrammingLanguage!) {
+                  programmingLanguageManifest(programmingLanguage: $programmingLanguage) {
+                    id
+                    programmingLanguage
+                    dependencies {
+                      name
+                      semVer
+                      gitUrl
+                    }
+                  }
+                }
+              `, { programmingLanguage })
+                    .then(({ programmingLanguageManifest }) => {
+                    programmingLanguageManifest.dependencies.forEach((dependency) => {
+                        if (programmingLanguage === 'PYTHON') {
+                            if (dependency.name === 'smtplib') {
+                                dependency.isNative = true;
+                            }
+                        }
+                    });
+                    return this.mapProgrammingLanguageManifest(programmingLanguageManifest);
+                })
+                    .catch((error) => {
+                    return Promise.reject(this.cleanError(error));
+                });
+            }
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    inheritedTeam(resolvingTeamSlug) {
+        return resolvingTeamSlug && resolvingTeamSlug !== this.teamSlug ? resolvingTeamSlug : undefined;
+    }
+    mapWebhook(triggers) {
+        const webhookTrigger = triggers?.webhook;
+        if (!webhookTrigger) {
+            return undefined;
+        }
+        const webhook = { enabled: Boolean(webhookTrigger.enabled) };
+        const basicAuth = webhookTrigger.auth?.basicAuth;
+        if (basicAuth) {
+            // Prefer the expression form (env-var placeholders like $WEBHOOK_PASSWORD)
+            // over the resolved literal so placeholders round-trip on pull.
+            const username = basicAuth.expression?.username ?? basicAuth.username;
+            const password = basicAuth.expression?.password ?? basicAuth.password;
+            if (username != null) {
+                webhook.username = username;
+            }
+            if (password != null) {
+                webhook.password = password;
+            }
+        }
+        return webhook;
+    }
+    mapProcess({ id, slug, name, description, tags, script, readme, manifest, settings, triggers, resolvingTeamSlug }) {
+        const dependencies = _.map(manifest?.dependencies, (dependency) => {
+            return { name: dependency.name, specifier: dependency.gitUrl ?? dependency.semVer };
+        });
+        const metadata = { name, tags: tags ?? [] };
+        if (description != null) {
+            metadata.description = description;
+        }
+        const webhook = this.mapWebhook(triggers);
+        if (webhook) {
+            metadata.webhook = webhook;
+        }
+        if (settings?.formSettings) {
+            metadata.form = { enabled: Boolean(settings.formSettings.enabled) };
+        }
+        if (settings?.publicationConfig) {
+            metadata.visibility = { isPublic: Boolean(settings.publicationConfig.isPublic) };
+        }
+        return new types_1.Process(id, slug, script, readme, { dependencies }, settings, metadata, this.inheritedTeam(resolvingTeamSlug));
+    }
+    team() {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query team($slug: ID!) {
+            team(slug: $slug) {
+              slug
+              zoneId
+              errorHandlerConfig {
+                processId
+                tag
+              }
+              parentTeamSlugs
+            }
+          }
+        `, { slug: this.teamSlug })
+            .then(({ team }) => team)
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    pushTeam(update) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation updateTeam($slug: String!, $update: TeamUpdateInput!) {
+            updateTeam(slug: $slug, update: $update) {
+              slug
+              zoneId
+              errorHandlerConfig {
+                processId
+                tag
+              }
+              parentTeamSlugs
+            }
+          }
+        `, { slug: this.teamSlug, update })
+            .then(({ updateTeam: team }) => team)
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    mapProgrammingLanguageManifest(programmingLanguageManifest) {
+        const allDependencies = programmingLanguageManifest.nextInstallation?.dependencies || programmingLanguageManifest.dependencies;
+        const dependencies = _.map(allDependencies, (dependency) => {
+            if (!dependency.isNative) {
+                return { name: dependency.name, specifier: dependency.gitUrl ?? dependency.semVer };
+            }
+            return null;
+        })
+            .filter(Boolean)
+            .sort((a, b) => a && b && a.name.localeCompare(b.name));
+        return new types_1.ProgrammingLanguageManifest(programmingLanguageManifest.id, programmingLanguageManifest.programmingLanguage, programmingLanguageManifest.programmingLanguage, dependencies);
+    }
+    allProgrammingLanguageManifest() {
+        const result = [];
+        result.push(this.programmingLanguageManifest('JAVASCRIPT'));
+        result.push(this.programmingLanguageManifest('PYTHON'));
+        return Promise.all(result);
+    }
+    pushProgrammingLanguageManifest(programmingLanguageManifest) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation updateManifest($id: ID!, $input: ProgrammingLanguageManifestUpdateInput!) {
+            updateProgrammingLanguageManifest(id: $id, input: $input) {
+              id
+              programmingLanguage
+              dependencies {
+                name
+                semVer
+                gitUrl
+              }
+              nextInstallation {
+                status
+                error
+                dependencies {
+                  name
+                  semVer
+                  isNative
+                  gitUrl
+                }
+              }
+            }
+          }
+        `, {
+            id: programmingLanguageManifest.id,
+            input: { dependencies: programmingLanguageManifest.dependencies },
+        })
+            .then(({ updateProgrammingLanguageManifest: programmingLanguageManifest }) => {
+            return this.client
+                .request((0, graphql_request_1.gql) `
+              mutation installManifest($id: ID!) {
+                installProgrammingLanguageManifest(id: $id)
+              }
+            `, {
+                id: programmingLanguageManifest.id,
+            })
+                .then(() => {
+                return this.mapProgrammingLanguageManifest(programmingLanguageManifest);
+            })
+                .catch((error) => {
+                return Promise.reject(this.cleanError(error));
+            });
+        })
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    allServiceAccounts() {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query allServiceAccounts {
+            allServiceAccounts {
+              id
+              name
+              clientId
+              clientSecret
+            }
+          }
+        `)
+            .then(({ allServiceAccounts }) => allServiceAccounts.map(({ id, name, clientId, clientSecret }) => new types_1.ServiceAccount(id, name, clientId, clientSecret)))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    createServiceAccount(name) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation createServiceAccount($input: ServiceAccountInput!) {
+            createServiceAccount(input: $input) {
+              id
+              name
+              clientId
+              clientSecret
+            }
+          }
+        `, {
+            input: { name: name },
+        })
+            .then(({ createServiceAccount: serviceAccount }) => new types_1.ServiceAccount(serviceAccount.id, serviceAccount.name, serviceAccount.clientId, serviceAccount.clientSecret))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+}
+exports.default = FcodeGraphQLClient;