@aloma.io/integration-sdk 3.0.0-4

package/build/builder/index.d.mts

@@ -0,0 +1,11 @@
+import RuntimeContext from './runtime-context.mjs';
+export declare class Builder {
+    private data;
+    id(what: string): Builder;
+    version(what: string): Builder;
+    config(arg: any): Builder;
+    options(arg: any): Builder;
+    auth(arg: any): Builder;
+    build(): Promise<RuntimeContext>;
+    private discoverTypes;
+}

package/build/builder/index.mjs

@@ -0,0 +1,51 @@
+import fs from 'fs';
+import parseTypes from './transform/index.mjs';
+import RuntimeContext from './runtime-context.mjs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const notEmpty = (what, name) => {
+    if (!what?.trim())
+        throw new Error(`${name} cannot be empty`);
+    return what;
+};
+export class Builder {
+    data = { controller: './build/controller/.controller-for-types.mts' };
+    id(what) {
+        this.data.id = notEmpty(what, 'id');
+        return this;
+    }
+    version(what) {
+        this.data.version = notEmpty(what, 'version');
+        return this;
+    }
+    config(arg) {
+        return this;
+    }
+    options(arg) {
+        return this;
+    }
+    auth(arg) {
+        return this;
+    }
+    async build() {
+        const data = this.data;
+        notEmpty(data.id, 'id');
+        notEmpty(data.version, 'version');
+        await this.discoverTypes();
+        // validate config
+        // validate options
+        // validate auth
+        console.log('dirname', __dirname);
+        // @ts-ignore
+        const Controller = (await import(__dirname + '/../../../../../build/controller/index.mjs')).default;
+        return new RuntimeContext(new Controller(), this.data);
+    }
+    async discoverTypes() {
+        notEmpty(this.data.controller, 'controller');
+        const content = fs.readFileSync(this.data.controller);
+        const { text, methods } = parseTypes(this.data.controller);
+        this.data.types = text;
+        this.data.methods = methods;
+    }
+}

package/build/builder/runtime-context.d.mts

@@ -0,0 +1,7 @@
+import { AbstractController } from '../controller/index.mjs';
+export default class RuntimeContext {
+    private controller;
+    private data;
+    constructor(controller: AbstractController, data: any);
+    start(): Promise<void>;
+}

package/build/builder/runtime-context.mjs

@@ -0,0 +1,42 @@
+import { Connector } from '../internal/index.cjs';
+export default class RuntimeContext {
+    controller;
+    data;
+    constructor(controller, data) {
+        this.controller = controller;
+        this.data = data;
+    }
+    async start() {
+        const controller = this.controller;
+        const connector = new Connector({
+            id: this.data.id,
+            version: this.data.version,
+            name: `${this.data.id}/${this.data.version}`,
+        });
+        const resolvers = {};
+        const methods = [...this.data.methods, '__endpoint', '__configQuery', '__default'];
+        methods.forEach((method) => {
+            resolvers[method] = async (args) => {
+                console.log('call', method, args);
+                if (!methods.includes(method))
+                    throw new Error(`${method} not found`);
+                return controller[method](args);
+            };
+        });
+        console.log(this.data.types);
+        connector
+            .configure()
+            .types(this.data.types)
+            .resolvers(resolvers)
+            .main(async ({ newTask, updateTask, config, oauth, getClient }) => {
+            try {
+                await controller._doStop();
+                await controller._doStart(config, oauth, newTask, updateTask, getClient);
+            }
+            catch (e) {
+                console.log(e);
+            }
+        });
+        connector.run();
+    }
+}

package/build/builder/transform/index.d.mts

@@ -0,0 +1,5 @@
+declare const _default: (path: string) => {
+    text: any;
+    methods: string[];
+};
+export default _default;

package/build/builder/transform/index.mjs

@@ -0,0 +1,72 @@
+import { parseFromFiles } from '@ts-ast-parser/core';
+const transform = (meta) => {
+    if (!meta?.length)
+        throw new Error('metadata is empty');
+    meta = meta[0];
+    if (meta.getDeclarations()?.length !== 1) {
+        throw new Error('connector file needs to export default class');
+    }
+    const methods = {};
+    const decl = meta.getDeclarations()[0];
+    // todo validate getConstructors
+    const members = decl.getMethods().filter((member) => {
+        return !(member.isStatic() ||
+            member.isInherited() ||
+            member.getKind() !== 'Method' ||
+            member.getModifier() !== 'public' ||
+            member.getName().startsWith('_'));
+    });
+    const text = members
+        .map((member) => {
+        methods[member.getName()] = true;
+        return member
+            .getSignatures()
+            .map((sig) => {
+            const docs = sig.getJSDoc().serialize() || [];
+            const desc = docs.find((what) => what.kind === 'description')?.value;
+            const paramDocs = docs
+                .filter((what) => what.kind === 'param')
+                .map((what) => {
+                return ` * @param {${what.value.type}} ${what.value.name} - ${what.value.description || ''}`;
+            })
+                .join('\n') || ' *';
+            const params = sig
+                .getParameters()
+                .map((param) => {
+                const serialized = param.serialize();
+                switch (!!param.isNamed()) {
+                    case true:
+                        const tmp = param
+                            .getNamedElements()
+                            .map((p) => {
+                            const defaultVal = p.default != null ? ' = ' + p.default : '';
+                            return `${p.name}${defaultVal}`;
+                        })
+                            .join('; ');
+                        return `{${tmp}}: ${param.getType().text}`;
+                    case false:
+                        return `${param.getName()}: ${param.getType().text}`;
+                }
+            })
+                .join(', ');
+            const retVal = sig
+                .getReturnType()
+                .type.text.replace(/^Promise</, '')
+                .replace(/>$/, '');
+            return `
+/**
+ * ${desc || ''}
+ *
+${paramDocs}
+ **/    
+declare function ${member.getName()}(${params}): ${retVal};
+      `;
+        })
+            .join('\n');
+    })
+        .join('');
+    return { text, methods: Object.keys(methods) };
+};
+export default (path) => {
+    return transform(parseFromFiles([path]));
+};

package/build/controller/index.d.mts

@@ -0,0 +1,19 @@
+export declare abstract class AbstractController {
+    protected config: any;
+    protected client: any;
+    protected start(): Promise<void>;
+    protected stop(): Promise<void>;
+    protected configQuery(arg: any): Promise<any>;
+    protected fallback(arg: any): Promise<any>;
+    protected endpoint(arg: any): Promise<any>;
+    protected newTask(name: string, data: any): Promise<string>;
+    protected getClient({ baseUrl }: {
+        baseUrl: string;
+    }): Promise<any>;
+    protected updateTask(name: string, data: any): Promise<string>;
+    __endpoint(arg: any): Promise<any | null>;
+    __configQuery(arg: any): Promise<any | null>;
+    __default(arg: any): Promise<any | null>;
+    _doStart(config: any, client: any, newTask: any, updateTask: any, getClient: any): Promise<void>;
+    _doStop(): Promise<void>;
+}

package/build/controller/index.mjs

@@ -0,0 +1,44 @@
+export class AbstractController {
+    config;
+    client;
+    async start() { }
+    async stop() { }
+    configQuery(arg) {
+        return Promise.resolve({});
+    }
+    fallback(arg) {
+        throw new Error('method not found');
+    }
+    endpoint(arg) {
+        throw new Error('method not found');
+    }
+    async newTask(name, data) {
+        throw new Error('not implemented');
+    }
+    getClient({ baseUrl }) {
+        throw new Error('not implemented');
+    }
+    async updateTask(name, data) {
+        throw new Error('not implemented');
+    }
+    async __endpoint(arg) {
+        return Promise.resolve(null);
+    }
+    async __configQuery(arg) {
+        return this.configQuery(arg);
+    }
+    async __default(arg) {
+        return this.fallback(arg);
+    }
+    async _doStart(config, client, newTask, updateTask, getClient) {
+        this.config = config;
+        this.client = client;
+        this.newTask = newTask;
+        this.updateTask = updateTask;
+        this.getClient = getClient;
+        await this.start();
+    }
+    async _doStop() {
+        await this.stop();
+    }
+}

package/build/index.d.mts

@@ -0,0 +1,2 @@
+export * from './builder/index.mjs';
+export * from './controller/index.mjs';

package/build/index.mjs

@@ -0,0 +1,2 @@
+export * from './builder/index.mjs';
+export * from './controller/index.mjs';

package/build/internal/dispatcher/index.cjs

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Dispatcher {
+    constructor() {
+        this._config = { fields: {} };
+    }
+    main(what) {
+        this._main = what;
+        return this;
+    }
+    oauth(arg) {
+        if (arg.platformOAuth) {
+            this.config({
+                oauth: true,
+                fields: {
+                    oauthResult: {
+                        name: 'OAuth Result',
+                        placeholder: 'will be set by finishing the oauth flow',
+                        type: 'managed',
+                    },
+                },
+            });
+            return this;
+        }
+        if (!arg.authorizationURL)
+            throw new Error('need a authorizationURL');
+        if (!arg.tokenURL && !arg.finishOAuth)
+            throw new Error('need a tokenURL or finishOAuth()');
+        this._oauth = { ...arg };
+        this.config({
+            oauth: true,
+            fields: {
+                oauthResult: {
+                    name: 'OAuth Result',
+                    placeholder: 'will be set by finishing the oauth flow',
+                    type: 'managed',
+                },
+            },
+        });
+        if (arg.configurableClient) {
+            this.config({
+                fields: {
+                    clientId: {
+                        name: 'OAuth Client ID',
+                        placeholder: 'e.g. 1234',
+                        type: 'line',
+                    },
+                    clientSecret: {
+                        name: 'OAuth Client Secret',
+                        placeholder: 'e.g. axd5xde',
+                        type: 'line',
+                    },
+                },
+            });
+        }
+        return this;
+    }
+    types(what) {
+        this._types = what;
+        return this;
+    }
+    config({ fields, oauth }) {
+        this._config.oauth = this._config.oauth || oauth;
+        this._config.fields = { ...fields, ...this._config.fields };
+        return this;
+    }
+    resolvers(what) {
+        this._resolvers = { ...this._resolvers, ...what };
+        return this;
+    }
+    endpoint(what) {
+        this.config({
+            fields: {
+                _endpointToken: {
+                    name: 'Endpoint Token (set to enable the endpoint)',
+                    placeholder: 'e.g. 1234',
+                    type: 'line',
+                    plain: true,
+                    optional: true,
+                },
+            },
+        });
+        this.resolvers({ _endpoint: what });
+        return this;
+    }
+    startOAuth() {
+        throw new Error('oauth not configured');
+    }
+    finishOAuth() {
+        throw new Error('oauth not configured');
+    }
+    build() {
+        if (!this._types || !this._resolvers)
+            throw new Error('missing types or resolvers');
+        var local = this;
+        const _resolvers = { ...this._resolvers };
+        const main = this._main || (() => { });
+        const start = async (transport) => {
+            console.log('starting ...');
+            await main(transport);
+        };
+        const resolveMethod = (query) => {
+            let current = _resolvers;
+            while (query.length && current) {
+                current = current[query.shift()];
+            }
+            return current;
+        };
+        const execute = async ({ query, variables }) => {
+            if (!Array.isArray(query))
+                query = [query];
+            query = query
+                .filter((what) => !!what?.trim() && !['constructor', '__proto__', 'toString', 'toSource', 'prototype'].includes(what))
+                .slice(0, 20);
+            const method = resolveMethod(query);
+            console.log('found method', query, method);
+            if (!method && !_resolvers.__default)
+                throw new Error(`${query} not found`);
+            return method ? method(variables) : _resolvers.__default(variables ? { ...variables, __method: query } : variables);
+        };
+        const introspect = () => local._types;
+        const configSchema = () => local._config;
+        const processPacket = async (packet) => {
+            switch (packet.method()) {
+                case 'connector.introspect':
+                    const intro = await introspect({});
+                    return { configSchema: local._config, introspect: intro };
+                case 'connector.start-oauth':
+                    return await local.startOAuth(packet.args());
+                case 'connector.finish-oauth':
+                    return await local.finishOAuth(packet.args());
+                case 'connector.query':
+                    const ret = await execute(packet.args());
+                    return typeof ret === 'object' && !Array.isArray(ret) ? ret : { [packet.args().query]: ret };
+                case 'connector.set-config':
+                    await local.onConfig({ ...packet.args().secrets });
+                    return;
+            }
+            console.dir(packet, { depth: null });
+            throw new Error('cannot handle packet');
+        };
+        return {
+            introspect,
+            configSchema,
+            execute,
+            processPacket,
+            start,
+        };
+    }
+}
+module.exports = { Dispatcher };

package/build/internal/dispatcher/index.d.cts

@@ -0,0 +1,32 @@
+export class Dispatcher {
+    _config: {
+        fields: {};
+    };
+    main(what: any): this;
+    _main: any;
+    oauth(arg: any): this;
+    _oauth: any;
+    types(what: any): this;
+    _types: any;
+    config({ fields, oauth }: {
+        fields: any;
+        oauth: any;
+    }): this;
+    resolvers(what: any): this;
+    _resolvers: any;
+    endpoint(what: any): this;
+    startOAuth(): void;
+    finishOAuth(): void;
+    build(): {
+        introspect: () => any;
+        configSchema: () => {
+            fields: {};
+        };
+        execute: ({ query, variables }: {
+            query: any;
+            variables: any;
+        }) => Promise<any>;
+        processPacket: (packet: any) => Promise<any>;
+        start: (transport: any) => Promise<void>;
+    };
+}