@chift/chift-nodejs 0.0.1

package/src/modules/sync.ts

@@ -0,0 +1,77 @@
+import { components } from '../types/public-api/schema';
+import { InternalAPI } from './internalApi';
+import { ContextType } from '../types/sync';
+import { Consumer } from './consumer';
+import { Flow } from './flow';
+
+const Sync = (internalApi: InternalAPI, body: components['schemas']['SyncItem']) => {
+    const _internalApi: InternalAPI = internalApi;
+    const data = body;
+    const name = data.name;
+    const consumers = data.consumers;
+    const syncid = data.syncid;
+
+    const getFlows = () => {
+        return data.flows.map((flow) => Flow(_internalApi, flow, data.syncid, data.consumers));
+    };
+
+    const getFlowByName = (name: string) => {
+        const flow = data.flows.find((flow) => flow.name.toLowerCase() === name.toLowerCase());
+        if (flow) {
+            return Flow(_internalApi, flow, data.syncid, data.consumers);
+        }
+        return undefined;
+    };
+
+    const getFlowById = (id: string) => {
+        const flow = data.flows.find((flow) => flow.id === id);
+        if (flow) {
+            return Flow(_internalApi, flow, data.syncid, data.consumers);
+        }
+        return undefined;
+    };
+
+    /**
+     * Internal use: Used to create flow based on code and triggers.
+     * @param context
+     * @param process
+     * @returns flow
+     */
+    const createFlow = async (
+        context: ContextType,
+        process?: (consumer: typeof Consumer, context: any) => any
+    ) => {
+        const executionData = context.execution.data || {};
+        if (context.execution.type === 'code') {
+            const fullFunc = process?.toString();
+            const bodyFunc = fullFunc?.slice(fullFunc.indexOf('{') + 1, fullFunc.lastIndexOf('}'));
+            executionData['code'] = bodyFunc;
+        }
+
+        const { data: createFlowData }: { data: components['schemas']['ReadFlowItem'] } =
+            await _internalApi.post(`/syncs/${data.syncid}/flows`, {
+                name: context.name,
+                description: context.description,
+                execution: {
+                    type: context.execution.type,
+                    data: executionData,
+                },
+                trigger: context.trigger,
+                config: context.config,
+            });
+        const myflow = Flow(_internalApi, createFlowData, data.syncid, data.consumers, process);
+        return myflow;
+    };
+
+    return {
+        createFlow,
+        getFlows,
+        getFlowByName,
+        getFlowById,
+        name,
+        consumers,
+        syncid,
+    };
+};
+
+export { Sync };

package/src/modules/syncs.ts

@@ -0,0 +1,28 @@
+import { components } from '../types/public-api/schema';
+import { InternalAPI } from './internalApi';
+import { Sync } from './sync';
+
+const Syncs = (internalApi: InternalAPI) => {
+    const _internalApi: InternalAPI = internalApi;
+
+    const getSyncs = async () => {
+        const { data }: { data: components['schemas']['SyncItem'][] } = await _internalApi.get(
+            '/syncs'
+        );
+        return data.map((sync) => Sync(_internalApi, sync));
+    };
+
+    const getSyncById = async (syncid: string) => {
+        const { data }: { data: components['schemas']['SyncItem'] } = await _internalApi.get(
+            `/syncs/${syncid}`
+        );
+        return Sync(_internalApi, data);
+    };
+
+    return {
+        getSyncs,
+        getSyncById,
+    };
+};
+
+export { Syncs };

package/src/modules/webhooks.ts

@@ -0,0 +1,86 @@
+import { operations } from '../types/public-api/schema';
+import { InternalAPI } from './internalApi';
+import { chiftOperations } from '../types/public-api/mappings';
+
+const Webhooks = (internalApi: InternalAPI) => {
+    const _internalApi: InternalAPI = internalApi;
+
+    const getWebhookTypes = async () => {
+        const {
+            data,
+        }: {
+            data: operations[chiftOperations['getWebhookTypes']]['responses'][200]['content']['application/json'];
+        } = await _internalApi.get('/webhooks/list');
+        return data;
+    };
+
+    const getWebhooks = async () => {
+        const {
+            data,
+        }: {
+            data: operations[chiftOperations['getWebhooks']]['responses'][200]['content']['application/json'];
+        } = await _internalApi.get('/webhooks');
+        return data;
+    };
+
+    const registerWebhook = async (
+        body: operations[chiftOperations['registerWebhook']]['requestBody']['content']['application/json']
+    ) => {
+        const {
+            data,
+        }: {
+            data: operations[chiftOperations['createConsumer']]['responses'][200]['content']['application/json'];
+        } = await _internalApi.post('/webhooks', body);
+        return data;
+    };
+
+    const getWebhookById = async (webhookId: string) => {
+        const {
+            data,
+        }: {
+            data: operations[chiftOperations['getWebhookById']]['responses'][200]['content']['application/json'];
+        } = await _internalApi.get(`/webhooks/${webhookId}`);
+        return data;
+    };
+
+    const updateWebhookById = async (
+        webhookId: string,
+        body: operations[chiftOperations['updateWebhookById']]['requestBody']['content']['application/json']
+    ) => {
+        const {
+            data,
+        }: {
+            data: operations[chiftOperations['updateConsumer']]['responses'][200]['content']['application/json'];
+        } = await _internalApi.patch(`/webhooks/${webhookId}`, body);
+        return data;
+    };
+
+    const unRegisterWebhook = async (webhookId: string) => {
+        const {
+            data,
+        }: { data: operations[chiftOperations['unRegisterWebhook']]['responses'][204] } =
+            await _internalApi.delete(`/webhooks/${webhookId}`);
+        return data;
+    };
+
+    const getWebhookLogsByWebhookId = async (webhookId: string) => {
+        const {
+            data,
+        }: {
+            data: operations[chiftOperations['getWebhookLogsByWebhookId']]['responses'][200]['content']['application/json'];
+        } = await _internalApi.get(`/webhooks/${webhookId}/logs`);
+        return data;
+    };
+
+    return {
+        getWebhookTypes,
+        registerWebhook,
+        getWebhookById,
+        updateWebhookById,
+        unRegisterWebhook,
+        getWebhookLogsByWebhookId,
+        getWebhooks,
+    };
+};
+
+export { Webhooks };

package/src/types/api.ts

@@ -0,0 +1,35 @@
+export interface AuthType {
+    clientId: string;
+    clientSecret: string;
+    accountId: string;
+    envId?: string;
+    baseUrl?: string;
+}
+
+export interface TokenType {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    expires_on: number;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type RequestData<TResponse> = {
+    method: string;
+    property?: string;
+    consumerName?: string;
+    consumerId?: string;
+    url: string;
+    params?: unknown;
+    body?: unknown;
+};
+
+export type RequestFactory = { [key: string]: (...args: any) => RequestData<any> };
+
+export type ApiFor<TFactory extends RequestFactory> = {
+    [key in keyof TFactory]: TFactory[key] extends (
+        ...args: infer TArgs
+    ) => RequestData<infer TResponse>
+        ? (...args: TArgs) => Promise<TResponse>
+        : never;
+};

package/src/types/consumers.ts

@@ -0,0 +1,9 @@
+export interface Consumers {
+    method: void;
+}
+
+export interface ConsumerLog {
+    type: string;
+    message: string;
+    context: any;
+}

package/src/types/public-api/mappings.ts

@@ -0,0 +1,21 @@
+export type chiftOperations = {
+    getConsumers: 'consumers_get_consumers';
+    createConsumer: 'consumers_create_consumer';
+    getConsumerById: 'consumers_get_consumer';
+    updateConsumer: 'consumers_update_consumer';
+    deleteConsumerById: 'consumers_delete_consumer';
+    getConnectionsByConsumerId: 'connections_get_connections';
+    createConnection: 'connections_create_connection';
+    deleteConnectionById: 'connections_delete_connection';
+    updateConnection: 'connections_update_connection';
+    getSyncs: 'syncs_get_syncs';
+    getIntegrations: 'integrations_get_integrations';
+    getWebhookTypes: 'webhooks_get_webhook_types';
+    getWebhooks: 'webhooks_get_webhooks';
+    registerWebhook: 'webhooks_create_webhook';
+    unRegisterWebhook: 'webhooks_delete_webhook';
+    getWebhookById: 'webhooks_get_webhook';
+    updateWebhookById: 'webhooks_update_webhook';
+    getWebhookLogsByWebhookId: 'webhooks_get_webhook_logs';
+    getSync: 'syncs_get_sync';
+};