@extrahorizon/exh-cli 1.12.0-dev-131-de586fc → 1.12.0-feat-132-3d57f4e

package/build/commands/data/schemas/delete.d.ts

@@ -4,7 +4,6 @@ export declare const desc = "Delete a schema";
 export declare const builder: (yargs: any) => import("yargs").Argv<{
     id: string;
 }>;
-export declare const handler: ({ sdk, id }: {
-    sdk: any;
+export declare const handler: ({ id }: {
     id: any;
 }) => Promise<void>;

package/build/commands/data/schemas/delete.js

@@ -12,13 +12,13 @@ const builder = (yargs) => (0, util_1.epilogue)(yargs).option('id', {
     type: 'string',
 });
 exports.builder = builder;
-const handler = async ({ sdk, id }) => {
-    const disableResponse = await schemaRepository.disable(sdk, id);
+const handler = async ({ id }) => {
+    const disableResponse = await schemaRepository.disable(id);
     if (disableResponse.affectedRecords !== 1) {
         console.log(chalk.red('Failed to delete schema', id));
         return;
     }
-    const deleteResponse = await schemaRepository.remove(sdk, id);
+    const deleteResponse = await schemaRepository.remove(id);
     if (deleteResponse.affectedRecords) {
         console.log(chalk.green('Successfully deleted schema', id));
     }

package/build/commands/data/schemas/list.d.ts

@@ -2,7 +2,6 @@
 export declare const command = "list";
 export declare const desc = "List all schemas";
 export declare const builder: (yargs: any) => import("yargs").Argv<{}>;
-export declare const handler: ({ sdk, isTTY }: {
-    sdk: any;
+export declare const handler: ({ isTTY }: {
     isTTY: any;
 }) => Promise<void>;

package/build/commands/data/schemas/list.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const exh_1 = require("../../../exh");
 const util_1 = require("../../../helpers/util");
 exports.command = 'list';
 exports.desc = 'List all schemas';
 const builder = (yargs) => (0, util_1.epilogue)(yargs);
 exports.builder = builder;
-const handler = async function list({ sdk, isTTY }) {
-    const schemaListResponse = await sdk.raw.get('/data/v1/');
+const handler = async function list({ isTTY }) {
+    const schemaListResponse = await (0, exh_1.getSdk)().raw.get('/data/v1/');
     if (schemaListResponse.data.data.length !== 0) {
         if (isTTY) {
             console.table(schemaListResponse.data.data.map((c) => ({ Id: c.id, Name: c.name, Description: c.description || '<none>' })));

package/build/commands/data/schemas/sync.d.ts

@@ -24,12 +24,11 @@ export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs
         default: boolean;
     };
 }>>;
-export declare const handler: ({ sdk, dir, file, dry, ignoreVerificationErrors }: {
-    sdk: any;
+export declare const handler: ({ dir, file, dry, ignoreVerificationErrors }: {
     dir: any;
     file: any;
     dry: any;
     ignoreVerificationErrors: any;
 }) => Promise<void>;
-export declare function syncTargetFile(sdk: any, targetFile: string, dry?: boolean, ignoreVerificationErrors?: boolean): Promise<void>;
-export declare function syncTargetDir(sdk: any, targetDir: string, dry?: boolean, ignoreVerificationErrors?: boolean): Promise<void>;
+export declare function syncTargetFile(targetFile: string, dry?: boolean, ignoreVerificationErrors?: boolean): Promise<void>;
+export declare function syncTargetDir(targetDir: string, dry?: boolean, ignoreVerificationErrors?: boolean): Promise<void>;

package/build/commands/data/schemas/sync.js

@@ -34,20 +34,20 @@ const builder = (yargs) => (0, util_1.epilogue)(yargs).options({
     },
 });
 exports.builder = builder;
-const handler = async ({ sdk, dir, file, dry, ignoreVerificationErrors }) => {
+const handler = async ({ dir, file, dry, ignoreVerificationErrors }) => {
     if (!file && !dir) {
         console.log(chalk.red('No target is chosen to be synced. Please use flags "--file" or "--dir" when syncing'));
         process.exit(1);
     }
     if (dir) {
-        await syncTargetDir(sdk, path.resolve(dir || '.'), dry, ignoreVerificationErrors);
+        await syncTargetDir(path.resolve(dir || '.'), dry, ignoreVerificationErrors);
     }
     if (file) {
-        await syncTargetFile(sdk, path.resolve(file), dry, ignoreVerificationErrors);
+        await syncTargetFile(path.resolve(file), dry, ignoreVerificationErrors);
     }
 };
 exports.handler = handler;
-async function syncTargetFile(sdk, targetFile, dry, ignoreVerificationErrors) {
+async function syncTargetFile(targetFile, dry, ignoreVerificationErrors) {
     await (0, verify_1.handler)({ dir: null, file: targetFile, ignoreVerificationErrors });
     const filePath = path.resolve(targetFile);
     if (!filePath.endsWith('.json')) {
@@ -56,15 +56,15 @@ async function syncTargetFile(sdk, targetFile, dry, ignoreVerificationErrors) {
     else {
         console.log(chalk.bold(`Synchronizing ${path.basename(filePath)}`));
         const targetSchema = await (0, readJson_1.readJsonFile)(filePath);
-        const syncSchema = syncSchema_1.SyncSchema.createSchemaSync(sdk, dry);
+        const syncSchema = syncSchema_1.SyncSchema.createSchemaSync(dry);
         await syncSchema.sync(targetSchema);
     }
 }
 exports.syncTargetFile = syncTargetFile;
-async function syncTargetDir(sdk, targetDir, dry, ignoreVerificationErrors) {
+async function syncTargetDir(targetDir, dry, ignoreVerificationErrors) {
     const targetFiles = (0, listFilesInDir_1.flatListFiles)(targetDir, '.json');
     for (const filePath of targetFiles) {
-        await syncTargetFile(sdk, filePath, dry, ignoreVerificationErrors);
+        await syncTargetFile(filePath, dry, ignoreVerificationErrors);
         process.stdout.write('\n');
     }
 }

package/build/commands/data/schemas/util/syncSchema.d.ts

@@ -1,11 +1,10 @@
 export declare class SyncSchema {
     #private;
-    private sdk;
     private dry;
     private cloudSchema;
     private localSchema;
-    static createSchemaSync(sdk: any, dry?: boolean): SyncSchema;
-    constructor(sdk: any, dry?: boolean);
+    static createSchemaSync(dry?: boolean): SyncSchema;
+    constructor(dry?: boolean);
     sync(target: any): Promise<void>;
 }
 export declare type Changes = {

package/build/commands/data/schemas/util/syncSchema.js

@@ -13,15 +13,14 @@ const schemaRepository = require("../../../../repositories/schemas");
 const statusHelpers_1 = require("../sync/statusHelpers");
 const stripUnsupportedDescriptionFields_1 = require("./stripUnsupportedDescriptionFields");
 class SyncSchema {
-    constructor(sdk, dry) {
+    constructor(dry) {
         _SyncSchema_instances.add(this);
         this.cloudSchema = null;
         this.localSchema = null;
-        this.sdk = sdk;
         this.dry = dry;
     }
-    static createSchemaSync(sdk, dry) {
-        return new SyncSchema(sdk, dry);
+    static createSchemaSync(dry) {
+        return new SyncSchema(dry);
     }
     async sync(target) {
         this.localSchema = (0, stripUnsupportedDescriptionFields_1.stripUnsupportedDescriptionFields)(target);
@@ -30,13 +29,13 @@ class SyncSchema {
             return;
         }
         console.log(`Syncing ${this.localSchema.name}`);
-        this.cloudSchema = await schemaRepository.fetchSchemaByName(this.sdk, this.localSchema.name);
+        this.cloudSchema = await schemaRepository.fetchSchemaByName(this.localSchema.name);
         if (!this.cloudSchema) {
             if (this.dry) {
                 console.log(`\t-> Will be created: ${chalk.green(this.localSchema.name)}`);
                 return;
             }
-            this.cloudSchema = await schemaRepository.createSchema(this.sdk, this.localSchema.name, this.localSchema.description);
+            this.cloudSchema = await schemaRepository.createSchema(this.localSchema.name, this.localSchema.description);
         }
         await __classPrivateFieldGet(this, _SyncSchema_instances, "m", _SyncSchema_syncRootAttributes).call(this);
         await __classPrivateFieldGet(this, _SyncSchema_instances, "m", _SyncSchema_syncProperties).call(this);
@@ -55,7 +54,7 @@ _SyncSchema_instances = new WeakSet(), _SyncSchema_syncRootAttributes = async fu
         return;
     }
     if (Object.keys(diff).length > 0) {
-        await schemaRepository.updateSchema(this.sdk, this.cloudSchema.id, diff);
+        await schemaRepository.updateSchema(this.cloudSchema.id, diff);
     }
 }, _SyncSchema_syncProperties = async function _SyncSchema_syncProperties() {
     const propertiesDiff = compareSchemaKey(this.localSchema, this.cloudSchema, 'properties');
@@ -66,18 +65,18 @@ _SyncSchema_instances = new WeakSet(), _SyncSchema_syncRootAttributes = async fu
     const { toAdd, toRemove, toUpdate } = propertiesDiff;
     for (const key of toAdd) {
         console.log(`properties: adding ${key}`);
-        await schemaRepository.createProperty(this.sdk, this.cloudSchema.id, {
+        await schemaRepository.createProperty(this.cloudSchema.id, {
             name: key,
             configuration: this.localSchema.properties[key],
         });
     }
     for (const key of toUpdate) {
         console.log(`properties: updating ${key}`);
-        await schemaRepository.updateProperty(this.sdk, this.cloudSchema.id, key, this.localSchema.properties[key]);
+        await schemaRepository.updateProperty(this.cloudSchema.id, key, this.localSchema.properties[key]);
     }
     for (const key of toRemove) {
         console.log(`properties: removing ${key}`);
-        await schemaRepository.deleteProperty(this.sdk, this.cloudSchema.id, key);
+        await schemaRepository.deleteProperty(this.cloudSchema.id, key);
     }
 }, _SyncSchema_updateStatuses = async function _SyncSchema_updateStatuses() {
     const changes = (0, statusHelpers_1.compareStatuses)(this.localSchema, this.cloudSchema);
@@ -88,12 +87,12 @@ _SyncSchema_instances = new WeakSet(), _SyncSchema_syncRootAttributes = async fu
     const { toAdd, toUpdate } = changes;
     for (const key of toAdd) {
         console.log(`statuses: adding ${key}`);
-        await schemaRepository.createStatus(this.sdk, this.cloudSchema.id, key, this.localSchema.statuses[key]);
+        await schemaRepository.createStatus(this.cloudSchema.id, key, this.localSchema.statuses[key]);
     }
     for (const key of toUpdate) {
         console.log(`statuses: updating ${key}`);
         const data = (0, statusHelpers_1.calculateStatusUpdateData)(this.localSchema.statuses[key], this.cloudSchema.statuses[key]);
-        await schemaRepository.updateStatus(this.sdk, this.cloudSchema.id, key, data);
+        await schemaRepository.updateStatus(this.cloudSchema.id, key, data);
     }
 }, _SyncSchema_syncCreationTransition = async function _SyncSchema_syncCreationTransition() {
     if (!this.localSchema.creationTransition) {
@@ -106,7 +105,7 @@ _SyncSchema_instances = new WeakSet(), _SyncSchema_syncRootAttributes = async fu
             return;
         }
         console.log('creation transition: updating');
-        await schemaRepository.updateCreationTransition(this.sdk, this.cloudSchema.id, this.localSchema.creationTransition);
+        await schemaRepository.updateCreationTransition(this.cloudSchema.id, this.localSchema.creationTransition);
     }
 }, _SyncSchema_syncTransitions = async function _SyncSchema_syncTransitions() {
     const transitionsDiff = compareSchemaKey(this.localSchema, this.cloudSchema, 'transitions');
@@ -117,16 +116,16 @@ _SyncSchema_instances = new WeakSet(), _SyncSchema_syncRootAttributes = async fu
     const { toAdd, toRemove, toUpdate } = transitionsDiff;
     for (const transition of toAdd) {
         console.log(`transitions: adding ${transition.name}`);
-        await schemaRepository.createTransition(this.sdk, this.cloudSchema.id, transition);
+        await schemaRepository.createTransition(this.cloudSchema.id, transition);
     }
     for (const transition of toUpdate) {
         console.log(`transitions: updating ${transition.name}`);
         const currentTransition = findTransitionByName(transition.name, this.cloudSchema.transitions);
-        await schemaRepository.updateTransition(this.sdk, this.cloudSchema.id, currentTransition.id, transition);
+        await schemaRepository.updateTransition(this.cloudSchema.id, currentTransition.id, transition);
     }
     for (const transition of toRemove) {
         console.log(`transitions: removing ${transition.name}`);
-        await schemaRepository.deleteTransition(this.sdk, this.cloudSchema.id, transition.id);
+        await schemaRepository.deleteTransition(this.cloudSchema.id, transition.id);
     }
 }, _SyncSchema_pruneStatuses = async function _SyncSchema_pruneStatuses() {
     if (this.dry) {
@@ -135,7 +134,7 @@ _SyncSchema_instances = new WeakSet(), _SyncSchema_syncRootAttributes = async fu
     const excessStatuses = _.difference(Object.keys(this.cloudSchema.statuses), Object.keys(this.localSchema.statuses));
     for (const key of excessStatuses) {
         console.log(`statuses: removing ${key}`);
-        await schemaRepository.deleteStatus(this.sdk, this.cloudSchema.id, key);
+        await schemaRepository.deleteStatus(this.cloudSchema.id, key);
     }
 }, _SyncSchema_syncIndexes = async function _SyncSchema_syncIndexes() {
     const { newIndexes, removedIndexes } = compareIndexes(this.localSchema, this.cloudSchema);
@@ -145,11 +144,11 @@ _SyncSchema_instances = new WeakSet(), _SyncSchema_syncRootAttributes = async fu
     }
     for (const idx of removedIndexes) {
         console.log(`Indexes: remove index ${idx.id}`);
-        await schemaRepository.deleteIndex(this.sdk, this.cloudSchema.id, idx.id);
+        await schemaRepository.deleteIndex(this.cloudSchema.id, idx.id);
     }
     for (const idx of newIndexes) {
         console.log('\t-> Creating new index');
-        await schemaRepository.createIndex(this.sdk, this.cloudSchema.id, idx);
+        await schemaRepository.createIndex(this.cloudSchema.id, idx);
     }
 };
 function deepDiff(object, other) {

package/build/commands/dispatchers/sync.d.ts

@@ -1,4 +1,3 @@
-import { OAuth1Client } from '@extrahorizon/javascript-sdk';
 import { Argv } from 'yargs';
 export declare const command = "sync";
 export declare const desc = "Synchronize Dispatchers, if a declared Dispatcher does not exist, it will be created";
@@ -14,8 +13,7 @@ export declare const builder: (yargs: Argv) => Argv<import("yargs").Omit<{}, "fi
         type: "boolean";
     };
 }>>;
-export declare const handler: ({ sdk, file, clean }: {
-    sdk: OAuth1Client;
+export declare const handler: ({ file, clean }: {
     file: string;
     clean: boolean;
 }) => Promise<void>;

package/build/commands/dispatchers/sync.js

@@ -18,7 +18,7 @@ const builder = (yargs) => (0, util_1.epilogue)(yargs).options({
     },
 });
 exports.builder = builder;
-const handler = async ({ sdk, file, clean }) => {
-    await dispatchersService.sync(sdk, file, clean);
+const handler = async ({ file, clean }) => {
+    await dispatchersService.sync(file, clean);
 };
 exports.handler = handler;

package/build/commands/localizations/sync.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="yargs" />
-import { OAuth1Client } from '@extrahorizon/javascript-sdk';
 export declare const command = "sync";
 export declare const desc = "Sync all localizations in a directory with the ExH cloud";
 export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs").Omit<{}, "path"> & import("yargs").InferredOptionTypes<{
@@ -10,7 +9,6 @@ export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs
         default: string;
     };
 }>>;
-export declare const handler: ({ sdk, path }: {
-    sdk: OAuth1Client;
+export declare const handler: ({ path }: {
     path?: string;
 }) => Promise<void>;

package/build/commands/localizations/sync.js

@@ -14,7 +14,7 @@ const builder = (yargs) => (0, util_1.epilogue)(yargs).options({
     },
 });
 exports.builder = builder;
-const handler = async ({ sdk, path }) => {
-    await localizationsService.sync(sdk, path);
+const handler = async ({ path }) => {
+    await localizationsService.sync(path);
 };
 exports.handler = handler;

package/build/commands/sync.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="yargs" />
-import { OAuth1Client } from '@extrahorizon/javascript-sdk';
 export declare const command = "sync";
 export declare const desc = "Sync your ExH configuration to the cloud environment";
 export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs").Omit<{}, "path" | "schemas" | "tasks" | "dispatchers" | "localizations" | "templates" | "cleanDispatchers" | "ignoreSchemaVerificationErrors"> & import("yargs").InferredOptionTypes<{
@@ -50,8 +49,7 @@ export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs
         default: boolean;
     };
 }>>;
-export declare const handler: ({ sdk, path, schemas, tasks, templates, dispatchers, cleanDispatchers, localizations, ignoreSchemaVerificationErrors, }: {
-    sdk: OAuth1Client;
+export declare const handler: ({ path, schemas, tasks, templates, dispatchers, cleanDispatchers, localizations, ignoreSchemaVerificationErrors, }: {
     path?: string;
     schemas?: boolean;
     tasks?: boolean;

package/build/commands/sync.js

@@ -78,32 +78,32 @@ If not, the local directory is assumed with a default configuration which assume
     return true;
 });
 exports.builder = builder;
-const handler = async ({ sdk, path, schemas, tasks, templates, dispatchers, cleanDispatchers, localizations, ignoreSchemaVerificationErrors, }) => {
+const handler = async ({ path, schemas, tasks, templates, dispatchers, cleanDispatchers, localizations, ignoreSchemaVerificationErrors, }) => {
     const targetPath = path || '.';
     const cfg = await (0, repoConfig_1.getRepoConfig)(targetPath);
     const syncAll = !(schemas || tasks || templates || dispatchers || localizations);
     if ((syncAll || schemas) && cfg.schemas) {
         console.log(chalk.green('\n ⚙️  Syncing schemas ...'));
         for (const schema of cfg.schemas) {
-            await (0, sync_1.syncTargetDir)(sdk, ospath.join(targetPath, schema), undefined, ignoreSchemaVerificationErrors);
+            await (0, sync_1.syncTargetDir)(ospath.join(targetPath, schema), undefined, ignoreSchemaVerificationErrors);
         }
     }
     if ((syncAll || templates) && cfg.templates) {
         console.log(chalk.green('\n ⚙️  Syncing templates...'));
         for (const template of cfg.templates) {
-            await (0, sync_3.handler)({ sdk, path: ospath.join(targetPath, template), template: null });
+            await (0, sync_3.handler)({ path: ospath.join(targetPath, template), template: null });
         }
     }
     if ((syncAll || tasks) && cfg.tasks) {
         console.log(chalk.green('\n ⚙️  Syncing tasks...'));
         for (const task of cfg.tasks) {
-            await (0, sync_2.handler)({ sdk, path: ospath.join(targetPath, task) });
+            await (0, sync_2.handler)({ path: ospath.join(targetPath, task) });
         }
     }
     if ((syncAll || localizations) && cfg.localizations) {
         console.log(chalk.green('\n ⚙️  Syncing localizations...'));
         for (const localization of cfg.localizations) {
-            await (0, localizations_1.sync)(sdk, ospath.join(targetPath, localization));
+            await (0, localizations_1.sync)(ospath.join(targetPath, localization));
         }
     }
     if ((syncAll || dispatchers)) {
@@ -111,7 +111,7 @@ const handler = async ({ sdk, path, schemas, tasks, templates, dispatchers, clea
         const isValidPath = (0, fs_1.existsSync)(dispatchersPath);
         if (isValidPath) {
             console.log(chalk.green('\n ⚙️  Syncing dispatchers...'));
-            await (0, dispatchers_1.sync)(sdk, dispatchersPath, cleanDispatchers);
+            await (0, dispatchers_1.sync)(dispatchersPath, cleanDispatchers);
         }
         else if (dispatchers) {
             console.log(chalk.yellow('Warning: dispatchers.json not found'));

package/build/commands/tasks/delete.d.ts

@@ -4,7 +4,6 @@ export declare const desc = "Delete a task";
 export declare const builder: (yargs: any) => import("yargs").Argv<{
     name: string;
 }>;
-export declare const handler: ({ sdk, name }: {
-    sdk: any;
+export declare const handler: ({ name }: {
     name: any;
 }) => Promise<void>;

package/build/commands/tasks/delete.js

@@ -12,9 +12,9 @@ const builder = (yargs) => (0, util_1.epilogue)(yargs).option('name', {
     type: 'string',
 });
 exports.builder = builder;
-const handler = async ({ sdk, name }) => {
+const handler = async ({ name }) => {
     try {
-        const response = await functionRepository.remove(sdk, name);
+        const response = await functionRepository.remove(name);
         if (response?.affectedRecords) {
             console.log(chalk.green('Successfully deleted task', name));
         }

package/build/commands/tasks/list.d.ts

@@ -2,7 +2,6 @@
 export declare const command = "list";
 export declare const desc = "List all tasks";
 export declare const builder: (yargs: any) => import("yargs").Argv<{}>;
-export declare const handler: ({ sdk, isTTY }: {
-    sdk: any;
+export declare const handler: ({ isTTY }: {
     isTTY: any;
 }) => Promise<void>;

package/build/commands/tasks/list.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const exh_1 = require("../../exh");
 const util_1 = require("../../helpers/util");
 exports.command = 'list';
 exports.desc = 'List all tasks';
 const builder = (yargs) => (0, util_1.epilogue)(yargs);
 exports.builder = builder;
-const handler = async function list({ sdk, isTTY }) {
+const handler = async function list({ isTTY }) {
     let functionResponse;
     try {
-        functionResponse = await sdk.raw.get('/tasks/v1/functions');
+        functionResponse = await (0, exh_1.getSdk)().raw.get('/tasks/v1/functions');
     }
     catch (err) {
         console.log(err);

package/build/commands/tasks/sync.d.ts

@@ -53,7 +53,6 @@ export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs
         type: "number";
     };
 }>>;
-export declare const handler: ({ sdk, ...cmdLineParams }: {
+export declare const handler: ({ ...cmdLineParams }: {
     [x: string]: any;
-    sdk: any;
 }) => Promise<void>;

package/build/commands/tasks/sync.js

@@ -71,17 +71,17 @@ const builder = (yargs) => (0, util_1.epilogue)(yargs).options({
     return true;
 });
 exports.builder = builder;
-const handler = async ({ sdk, ...cmdLineParams }) => {
+const handler = async ({ ...cmdLineParams }) => {
     for await (const config of (0, taskConfig_1.getValidatedConfigIterator)(cmdLineParams)) {
         console.log('Syncing task', config.name, '...');
-        await syncSingleTask(sdk, config);
+        await syncSingleTask(config);
     }
 };
 exports.handler = handler;
-async function syncSingleTask(sdk, config) {
+async function syncSingleTask(config) {
     const uploadFilePath = await (0, util_2.zipFileFromDirectory)(config.path);
     const file = await fs.readFile(uploadFilePath);
-    const allFunctions = await functionRepository.find(sdk);
+    const allFunctions = await functionRepository.find();
     const myFunction = allFunctions.find((f) => f.name === config.name);
     const request = {
         name: config.name,
@@ -109,7 +109,7 @@ async function syncSingleTask(sdk, config) {
         request.retryPolicy = config.retryPolicy;
     }
     if (config.executionCredentials) {
-        const credentials = await (0, util_2.syncFunctionUser)(sdk, {
+        const credentials = await (0, util_2.syncFunctionUser)({
             taskName: config.name,
             targetEmail: config.executionCredentials.email,
             targetPermissions: config.executionCredentials.permissions,
@@ -131,15 +131,15 @@ async function syncSingleTask(sdk, config) {
         request.environmentVariables = environmentVariables;
     }
     if (myFunction === undefined) {
-        await functionRepository.create(sdk, request);
+        await functionRepository.create(request);
         console.log(chalk.green('Successfully created task', config.name));
     }
     else {
-        const existingFunction = await functionRepository.findByName(sdk, myFunction.name);
+        const existingFunction = await functionRepository.findByName(myFunction.name);
         if (request.runtime === existingFunction.runtime) {
             delete request.runtime;
         }
-        const updateResponse = await functionRepository.update(sdk, request);
+        const updateResponse = await functionRepository.update(request);
         if (!updateResponse?.affectedRecords) {
             throw new Error(`Failed to update task ${request.name}`);
         }

package/build/commands/tasks/util.d.ts

@@ -1,6 +1,5 @@
-import { OAuth1Client } from '@extrahorizon/javascript-sdk';
 export declare function zipFileFromDirectory(path: string): Promise<string>;
-export declare function syncFunctionUser(sdk: OAuth1Client, data: {
+export declare function syncFunctionUser(data: {
     taskName: string;
     targetEmail?: string;
     targetPermissions: string[];

package/build/commands/tasks/util.js

@@ -30,18 +30,18 @@ async function zipFileFromDirectory(path) {
     });
 }
 exports.zipFileFromDirectory = zipFileFromDirectory;
-async function syncFunctionUser(sdk, data) {
+async function syncFunctionUser(data) {
     const { taskName, targetEmail, targetPermissions } = data;
     const email = (targetEmail || `exh.tasks+${taskName}@extrahorizon.com`).toLowerCase();
     validateEmail(email);
     const password = `0Oo-${randomHexString()}`;
     const roleName = `exh.tasks.${taskName}`;
-    const role = await syncRoleWithPermissions(sdk, taskName, roleName, targetPermissions);
-    let user = await userRepository.findUserByEmail(sdk, email);
+    const role = await syncRoleWithPermissions(taskName, roleName, targetPermissions);
+    let user = await userRepository.findUserByEmail(email);
     console.group(chalk.white(`🔄  Syncing user: ${email}`));
     if (!user) {
         console.log(chalk.white('⚙️  Creating the user...'));
-        user = await userRepository.createUser(sdk, {
+        user = await userRepository.createUser({
             firstName: `${taskName}`,
             lastName: 'exh.tasks',
             email,
@@ -49,14 +49,14 @@ async function syncFunctionUser(sdk, data) {
             phoneNumber: '0000000000',
             language: 'EN',
         });
-        await assignRoleToUser(sdk, user.id, role.id);
-        const oAuth1Tokens = await createOAuth1Tokens(sdk, email, password);
+        await assignRoleToUser(user.id, role.id);
+        const oAuth1Tokens = await createOAuth1Tokens(email, password);
         console.groupEnd();
         console.log(chalk.green('✅  Successfully synced user'));
         console.log('');
         return oAuth1Tokens;
     }
-    const currentFunction = await functionRepository.findByName(sdk, taskName);
+    const currentFunction = await functionRepository.findByName(taskName);
     const hasExistingCredentials = (currentFunction?.environmentVariables?.API_HOST?.value &&
         currentFunction?.environmentVariables?.API_OAUTH_TOKEN_SECRET?.value &&
         currentFunction?.environmentVariables?.API_OAUTH_TOKEN?.value &&
@@ -79,7 +79,7 @@ async function syncFunctionUser(sdk, data) {
     console.log(chalk.white('⚙️  Reusing existing user credentials...'));
     const userRole = user.roles?.find(({ name }) => name === roleName);
     if (!userRole) {
-        await assignRoleToUser(sdk, user.id, role.id);
+        await assignRoleToUser(user.id, role.id);
     }
     console.groupEnd();
     console.log(chalk.green('✅  Successfully synced user'));
@@ -90,18 +90,18 @@ async function syncFunctionUser(sdk, data) {
     };
 }
 exports.syncFunctionUser = syncFunctionUser;
-async function syncRoleWithPermissions(sdk, taskName, roleName, targetPermissions) {
+async function syncRoleWithPermissions(taskName, roleName, targetPermissions) {
     console.group(chalk.white(`🔄  Syncing role: ${roleName}`));
     if (targetPermissions.length === 0) {
         console.log(chalk.yellow('⚠️  The executionCredentials.permissions field has no permissions defined'));
     }
-    let role = await userRepository.findGlobalRoleByName(sdk, roleName);
+    let role = await userRepository.findGlobalRoleByName(roleName);
     if (!role) {
         console.log(chalk.white('⚙️  Creating the role...'));
         const roleDescription = `A role created by the CLI for the execution of the task ${taskName}`;
-        role = await userRepository.createGlobalRole(sdk, roleName, roleDescription);
+        role = await userRepository.createGlobalRole(roleName, roleDescription);
         if (targetPermissions.length !== 0) {
-            await userRepository.addPermissionsToGlobalRole(sdk, roleName, targetPermissions);
+            await userRepository.addPermissionsToGlobalRole(roleName, targetPermissions);
         }
         console.log(chalk.white(`🔐  Permissions added: [${targetPermissions.join(', ')}]`));
         console.groupEnd();
@@ -114,11 +114,11 @@ async function syncRoleWithPermissions(sdk, taskName, roleName, targetPermission
     const permissionsToAdd = targetPermissions.filter(targetPermission => !currentPermissions.includes(targetPermission));
     const permissionsToRemove = currentPermissions.filter(currentPermission => !targetPermissions.includes(currentPermission));
     if (permissionsToAdd.length > 0) {
-        await userRepository.addPermissionsToGlobalRole(sdk, roleName, permissionsToAdd);
+        await userRepository.addPermissionsToGlobalRole(roleName, permissionsToAdd);
         console.log(chalk.white(`🔐  Permissions added: [${permissionsToAdd.join(',')}]`));
     }
     if (permissionsToRemove.length > 0) {
-        await userRepository.removePermissionsFromGlobalRole(sdk, roleName, permissionsToRemove);
+        await userRepository.removePermissionsFromGlobalRole(roleName, permissionsToRemove);
         console.log(chalk.white(`🔐  Permissions removed: [${permissionsToRemove.join(',')}]`));
     }
     console.groupEnd();
@@ -126,13 +126,13 @@ async function syncRoleWithPermissions(sdk, taskName, roleName, targetPermission
     console.log('');
     return role;
 }
-async function assignRoleToUser(sdk, userId, roleId) {
+async function assignRoleToUser(userId, roleId) {
     console.log(chalk.white('⚙️  Assigning the role to the user...'));
-    await userRepository.addGlobalRoleToUser(sdk, userId, roleId);
+    await userRepository.addGlobalRoleToUser(userId, roleId);
 }
-async function createOAuth1Tokens(sdk, email, password) {
+async function createOAuth1Tokens(email, password) {
     console.log(chalk.white('⚙️  Creating credentials...'));
-    const response = await authRepository.createOAuth1Tokens(sdk, email, password);
+    const response = await authRepository.createOAuth1Tokens(email, password);
     const { token, tokenSecret } = response;
     return { token, tokenSecret };
 }

package/build/commands/templates/delete.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="yargs" />
-import { OAuth1Client } from '@extrahorizon/javascript-sdk';
 export declare const command = "delete";
 export declare const desc = "Delete a template";
 export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs").Omit<{}, "id" | "name"> & import("yargs").InferredOptionTypes<{
@@ -12,8 +11,7 @@ export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs
         type: "string";
     };
 }>>;
-export declare const handler: ({ sdk, name, id }: {
-    sdk: OAuth1Client;
+export declare const handler: ({ name, id }: {
     name: string;
     id: string;
 }) => Promise<void>;