@factorialco/fcode-cli 1.1.0

package/dist/services/auth-service.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable camelcase */
+const cli_1 = require("../utils/cli");
+const node_fetch_1 = require("node-fetch");
+const global_1 = require("../config/global");
+const color_1 = require("@oclif/color");
+const AUTH_URL_PATH = '/protocol/openid-connect';
+const AUTH_CLIENT_ID = 'cli';
+const AuthService = {
+    clientId: process.env.FCODE_CLIENT_ID || AUTH_CLIENT_ID,
+    async getToken({ authUrl, email, password, clientId, clientSecret }) {
+        let body;
+        let headers;
+        if (email && password) {
+            body = new URLSearchParams({
+                client_id: this.clientId,
+                grant_type: 'password',
+                password: password || '',
+                scope: 'openid',
+                username: email || '',
+            });
+            headers = {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            };
+        }
+        else if (clientId && clientSecret) {
+            body = new URLSearchParams({
+                grant_type: 'client_credentials',
+                scope: 'openid',
+            });
+            headers = {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Authorization: `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString('base64')}`,
+            };
+        }
+        else {
+            throw new Error('You must provide email/password or clientId/clientSecret');
+        }
+        const response = await (0, node_fetch_1.default)(`${authUrl}${AUTH_URL_PATH}/token`, {
+            body: body.toString(),
+            headers,
+            method: 'POST',
+        });
+        const token = await response.json();
+        if (response.ok) {
+            return token;
+        }
+        throw token.error_description;
+    },
+    async getUserInfo(authUrl, token) {
+        const response = await (0, node_fetch_1.default)(`${authUrl}${AUTH_URL_PATH}/userinfo`, {
+            headers: {
+                Authorization: `Bearer ${token.access_token}`,
+            },
+            method: 'GET',
+        });
+        const data = await response.json();
+        if (response.ok) {
+            return data;
+        }
+        throw data.error_description;
+    },
+    globalConfig: new global_1.default(),
+    async isAuthenticated(url) {
+        try {
+            const { authUrl, token } = await this.globalConfig.getAuthInfo(url);
+            try {
+                await this.getUserInfo(authUrl, token);
+            }
+            catch (error) {
+                await this.globalConfig.clearAuthInfo(url);
+                cli_1.default.log(color_1.default.yellow('🚪  Session expired, please login again'));
+                throw error;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    async login({ url, authUrl, email, password, clientId, clientSecret, accessToken }) {
+        const token = accessToken
+            ? { access_token: accessToken, refresh_token: '' }
+            : await this.getToken({ url, authUrl, email, password, clientId, clientSecret });
+        const userInfo = await this.getUserInfo(authUrl, token);
+        const authInfo = {
+            authUrl,
+            token,
+            userInfo,
+        };
+        await this.globalConfig.setAuthInfo(url, authInfo);
+        return authInfo;
+    },
+    async logout(url) {
+        const authInfo = await this.globalConfig.getAuthInfo(url);
+        if (authInfo) {
+            const body = new URLSearchParams({
+                client_id: this.clientId,
+                refresh_token: authInfo.token.refresh_token,
+            });
+            await (0, node_fetch_1.default)(`${url}/logout`, {
+                body: body.toString(),
+                headers: {
+                    Authorization: `Bearer ${authInfo.token.access_token}`,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                method: 'POST',
+            });
+            await this.globalConfig.clearAuthInfo(url);
+        }
+    },
+};
+exports.default = AuthService;

package/dist/services/credential-prompter.d.ts

@@ -0,0 +1,6 @@
+import type { Credentials } from '../core/types';
+declare function prompt(credentials?: Credentials): Promise<Credentials>;
+declare const _default: {
+    prompt: typeof prompt;
+};
+export default _default;

package/dist/services/credential-prompter.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_service_1 = require("./auth-service");
+const cli_1 = require("../utils/cli");
+const url_utils_1 = require("../utils/url-utils");
+const credentialsQuestions = {
+    email: () => cli_1.default.prompt('What is your fcode email?'),
+    password: () => cli_1.default.password('What is your fcode password (not stored)?'),
+};
+async function prompt(credentials) {
+    const auth = async (credentials) => {
+        let { authUrl, url, email, password, clientId, clientSecret } = credentials;
+        if (url.endsWith('/')) {
+            url = url.slice(0, -1);
+        }
+        if (authUrl && authUrl.endsWith('/')) {
+            authUrl = authUrl.slice(0, -1);
+        }
+        if (!clientId && !clientSecret) {
+            let message = `👤  Logging for Factorial Code account at ${url}`;
+            if (!(0, url_utils_1.isDefaultAuthUrl)(authUrl, url)) {
+                message += ` (with authUrl ${authUrl})`;
+            }
+            cli_1.default.log(message);
+            email ||= await credentialsQuestions.email();
+            password ||= await credentialsQuestions.password();
+        }
+        try {
+            cli_1.default.action.start('🔑  Checking credentials');
+            await auth_service_1.default.login({
+                authUrl,
+                url,
+                email,
+                password,
+                clientId,
+                clientSecret,
+            });
+            cli_1.default.action.stop();
+        }
+        catch (error) {
+            cli_1.default.action.stop();
+            cli_1.default.error('Bad credentials. Try again');
+            return auth({
+                authUrl: credentials.authUrl,
+                url: credentials.url,
+                email: '',
+                password: '',
+            });
+        }
+    };
+    return auth(credentials || {
+        authUrl: '',
+        url: '',
+        email: '',
+        password: '',
+    });
+}
+exports.default = {
+    prompt,
+};

package/dist/services/fcode-graphql-client.d.ts

@@ -0,0 +1,45 @@
+import { GraphQLClient } from 'graphql-request';
+import { Process, ProgrammingLanguage, ProgrammingLanguageManifest, RawTeamSettings, ScriptLibrary, TeamUpdateInput, Variable, VersionedProcess, VersionedScriptLibrary, ServiceAccount } from '../core/types';
+export type FcodeGraphQLClientOptions = {
+    url: string;
+    accessToken: string;
+    teamSlug: string;
+};
+declare class FcodeGraphQLClient {
+    client: GraphQLClient;
+    private teamSlug;
+    private url;
+    constructor(options: FcodeGraphQLClientOptions);
+    isDuplicatedError(error: any): boolean;
+    isEmptyValueError(error: any): boolean;
+    cleanError(error: any): any;
+    private cloudUnavailableMessage;
+    private isNetworkError;
+    allProcesses(): Promise<Array<Process>>;
+    allVersionedProcesses(processId: string): Promise<Array<VersionedProcess>>;
+    createVersionedProcesses(versionedProcess: VersionedProcess): Promise<void>;
+    allScriptLibraries(): Promise<Array<ScriptLibrary>>;
+    allVersionedScriptLibraries(scriptLibraryId: string): Promise<Array<VersionedScriptLibrary>>;
+    createVersionedScriptLibrary(versionedScriptLibrary: VersionedScriptLibrary): Promise<void>;
+    allVariables(): Promise<Array<Variable>>;
+    private toProcessInput;
+    pushProcess(process: Process): Promise<Process>;
+    removeProcess(id: String | undefined): Promise<Process>;
+    pushScriptLibrary(scriptLibrary: ScriptLibrary): Promise<ScriptLibrary>;
+    removeScriptLibrary(id: String | undefined): Promise<Process>;
+    pushVariable(variable: Variable): Promise<Variable>;
+    updateVariable(variable: Variable): Promise<Variable>;
+    removeVariable(id: String | undefined): Promise<Process>;
+    programmingLanguageManifest(programmingLanguage: ProgrammingLanguage): Promise<ProgrammingLanguageManifest>;
+    private inheritedTeam;
+    private mapWebhook;
+    mapProcess({ id, slug, name, description, tags, script, readme, manifest, settings, triggers, resolvingTeamSlug }: any): Process;
+    team(): Promise<RawTeamSettings>;
+    pushTeam(update: TeamUpdateInput): Promise<RawTeamSettings>;
+    mapProgrammingLanguageManifest(programmingLanguageManifest: any): ProgrammingLanguageManifest;
+    allProgrammingLanguageManifest(): Promise<Array<ProgrammingLanguageManifest>>;
+    pushProgrammingLanguageManifest(programmingLanguageManifest: ProgrammingLanguageManifest): Promise<ProgrammingLanguageManifest>;
+    allServiceAccounts(): Promise<Array<ServiceAccount>>;
+    createServiceAccount(name: string): Promise<ServiceAccount>;
+}
+export default FcodeGraphQLClient;