@ptkl/toolkit 0.3.0

package/dist/bin/toolkit.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { commands } from "../commands/index.js";
+const program = new Command();
+commands.forEach(c => program.addCommand(c));
+program.parseAsync(process.argv).catch((err) => {
+    const { response } = err;
+    if (response && response.data) {
+        console.error(response.data.message);
+        console.log(response);
+        return;
+    }
+    console.error(err.message);
+});

package/dist/builder/compiler.js

@@ -0,0 +1 @@
+export {};

package/dist/builder/index.js

@@ -0,0 +1,60 @@
+import { extname, join } from "path";
+// sdk compilers
+import Register from "./register.js";
+export default class Builder {
+    compiler;
+    constructor(sdkVersion, engine) {
+        this.compiler = Register.getCompiler(sdkVersion, engine);
+    }
+    async build(files) {
+        const dist = {};
+        let errors = [];
+        for (const file in files) {
+            try {
+                const fileExt = extname(file).substring(1);
+                if (this.compiler.getSupportedExt().includes(fileExt)) {
+                    dist[file] = await this.compiler.compile(fileExt, files[file]);
+                }
+            }
+            catch (error) {
+                errors.push(`${file}: ${error.message}`);
+            }
+        }
+        if (errors.length > 0) {
+            throw new BuildError(errors);
+        }
+        return dist;
+    }
+    nodesToFiles(nodes, basePath) {
+        let files = {};
+        nodes.forEach((node) => {
+            const currentPath = join(basePath, node.name);
+            if (node.isLeaf) {
+                files = Object.assign({}, files, {
+                    [currentPath]: node.content
+                });
+            }
+            else {
+                const childrenFiles = this.nodesToFiles(node.children ?? [], currentPath);
+                files = Object.assign({}, files, childrenFiles);
+            }
+        });
+        return files;
+    }
+    async buildFromNodes(nodes) {
+        const files = this.nodesToFiles(nodes, '');
+        return this.build(files);
+    }
+}
+export class BuildError extends Error {
+    errors;
+    constructor(errors) {
+        super(`Error during build: ${errors.join(", ")}`);
+        this.name = 'BuildError'; // Set the name to the class name
+        this.errors = errors;
+        // This is necessary to maintain the stack trace for instance creation
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, BuildError);
+        }
+    }
+}

package/dist/builder/register.js

@@ -0,0 +1,25 @@
+import CompilerSDK4 from "./sdk4/vue2.js";
+import CompilerSDK5 from "./sdk5/vue2.js";
+import CompilerSDK5Vue3 from "./sdk5/vue3.js";
+const latestVersion = 5;
+const defaultEngine = 'vue2';
+const compilers = {
+    'sdk4::vue2': new CompilerSDK4,
+    'sdk5::vue2': new CompilerSDK5,
+    'sdk5::vue3': new CompilerSDK5Vue3,
+};
+export default {
+    getCompiler(sdkVersion, engine) {
+        if (sdkVersion === undefined) {
+            sdkVersion = latestVersion;
+        }
+        if (!engine) {
+            engine = defaultEngine;
+        }
+        const compiler = compilers[`sdk${sdkVersion}::${engine}`];
+        if (!compiler) {
+            return new CompilerSDK4;
+        }
+        return compiler;
+    }
+};

package/dist/builder/sdk4/vue2.js

@@ -0,0 +1,69 @@
+import * as Babel from '@babel/standalone';
+import less from 'less';
+import { parse } from '@vue/compiler-sfc';
+export default class Compiler {
+    async compileVue(template) {
+        try {
+            const { descriptor = {} } = parse(template);
+            const styles = descriptor.styles.map((style) => style.content).join(" ");
+            const code = Babel.transform(descriptor?.script?.content ?? "", { sourceType: "module", presets: ["env"] }).code;
+            const css = await this.compileCSS(null, 'less', styles);
+            return {
+                template: this.getTmpl(template),
+                style: css,
+                script: code,
+            };
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+    getStringBetween(str, start, end) {
+        const result = str.match(new RegExp("(?:\\" + start + ")(.*)(?=\\" + end + ")", 'gs'));
+        if (result === null) {
+            return "";
+        }
+        return result[0].replace(start, "");
+    }
+    getTmpl(c) {
+        try {
+            return this.getStringBetween(c, "<tmpl>", "</tmpl>");
+        }
+        catch (err) {
+            throw new Error("Failed to parse template:" + err.message);
+        }
+    }
+    async compileBabel(expression) {
+        let code = Babel.transform(expression, { sourceType: "module", presets: ["env"] });
+        return code.code;
+    }
+    async compileCSS(scope, lang, expression) {
+        switch (lang) {
+            case 'less':
+                if (scope) {
+                    expression = `[data-scope="${scope}"] { ${expression} }`;
+                }
+                const { css } = await less.render(expression);
+                return css;
+            default:
+                return expression;
+        }
+    }
+    async compile(ext, content) {
+        switch (ext) {
+            case 'vue':
+                return await this.compileVue(content);
+            case 'js':
+                return await this.compileBabel(content);
+            case 'css':
+                return await this.compileCSS(null, "css", content);
+            case 'less':
+                return await this.compileCSS(null, "less", content);
+            default:
+                return await Promise.resolve(content);
+        }
+    }
+    getSupportedExt() {
+        return ["vue", "js", "css", "less", "json", "svg"];
+    }
+}

package/dist/builder/sdk5/vue2.js

@@ -0,0 +1,60 @@
+import * as Babel from '@babel/standalone';
+import less from 'less';
+import { compile } from 'vue-template-compiler';
+import { parse } from '@vue/compiler-sfc';
+export default class Compiler {
+    async compileVue(scope, template) {
+        try {
+            const { descriptor = {} } = parse(template);
+            const styles = descriptor.styles.map((style) => style.content).join(" ");
+            const code = Babel.transform(descriptor?.script?.content ?? "", { sourceType: "module", presets: ["env"] }).code;
+            const css = await this.compileCSS(null, 'less', styles);
+            const { render, staticRenderFns, errors } = compile(descriptor?.template?.content);
+            if (errors && errors.length > 0) {
+                throw new Error(errors.join(", "));
+            }
+            return {
+                style: css,
+                script: code,
+                render: render.toString(),
+                staticRenderFns: staticRenderFns
+            };
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+    async compileBabel(expression) {
+        let code = Babel.transform(expression, { sourceType: "module", presets: ["env"] });
+        return code.code;
+    }
+    async compileCSS(scope, lang, expression) {
+        switch (lang) {
+            case 'less':
+                if (scope) {
+                    return await less.render(`.${scope} { ${expression} }`);
+                }
+                const { css } = await less.render(`${expression}`);
+                return css;
+            default:
+                return expression;
+        }
+    }
+    async compile(ext, content) {
+        switch (ext) {
+            case 'vue':
+                return await this.compileVue(null, content);
+            case 'js':
+                return await this.compileBabel(content);
+            case 'css':
+                return await this.compileCSS(null, "css", content);
+            case 'less':
+                return await this.compileCSS(null, "less", content);
+            default:
+                return await Promise.resolve(content);
+        }
+    }
+    getSupportedExt() {
+        return ["vue", "js", "css", "less", "json", "svg"];
+    }
+}

package/dist/builder/sdk5/vue3.js

@@ -0,0 +1,56 @@
+import * as Babel from '@babel/standalone';
+import less from 'less';
+import { compile } from '@vue/compiler-dom';
+import { parse } from '@vue/compiler-sfc';
+export default class Compiler {
+    async compileVue(template) {
+        try {
+            const { descriptor = {} } = parse(template);
+            const styles = descriptor.styles.map((style) => style.content).join(" ");
+            const code = Babel.transform(descriptor?.script?.content ?? "", { sourceType: "module", presets: ["env"] }).code;
+            const css = await this.compileCSS(null, 'less', styles);
+            const { code: render } = compile(descriptor?.template?.content);
+            return {
+                style: css,
+                script: code,
+                render
+            };
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+    async compileBabel(expression) {
+        let code = Babel.transform(expression, { sourceType: "module", presets: ["env"] });
+        return code.code;
+    }
+    async compileCSS(scope, lang, expression) {
+        switch (lang) {
+            case 'less':
+                if (scope) {
+                    return await less.render(`.${scope} { ${expression} }`);
+                }
+                const { css } = await less.render(`${expression}`);
+                return css;
+            default:
+                return expression;
+        }
+    }
+    async compile(ext, content) {
+        switch (ext) {
+            case 'vue':
+                return await this.compileVue(content);
+            case 'js':
+                return await this.compileBabel(content);
+            case 'css':
+                return await this.compileCSS(null, "css", content);
+            case 'less':
+                return await this.compileCSS(null, "less", content);
+            default:
+                return await Promise.resolve(content);
+        }
+    }
+    getSupportedExt() {
+        return ["vue", "js", "css", "less", "json", "svg"];
+    }
+}

package/dist/commands/apiUsers.js

@@ -0,0 +1,74 @@
+import { Command } from "commander";
+import util from "../lib/util.js";
+import Api from "protokol-sdk";
+import OutputFormatCommand from "./outputCommand.js";
+class ApiUsersCommand {
+    register() {
+        return (new Command("api-users")
+            .description("Manage API users")
+            .version("0.1.0")
+            .addCommand(new OutputFormatCommand(new Command("new-secret")
+            .description("Create a new secret for a user")
+            .requiredOption("-u, --uuid <uuid>", "UUID of the user to create a new secret for")).action(this.newSecret))
+            .addCommand(new OutputFormatCommand(new Command("revoke-secret")
+            .description("Revoke an existing secret")
+            .requiredOption("-u, --uuid <uuid>", "UUID of the secret to revoke")).action(this.revokeSecret))
+            .addCommand(new OutputFormatCommand(new Command("get-auth-token")
+            .description("Retrieve an auth token for an API user")
+            .requiredOption("-u, --user <user>", "Username or name of the API user")
+            .requiredOption("-p, --password <password>", "Password or secret for the API user")).action(this.getAuthToken))
+            // .addCommand(  new OutputFormatCommand(
+            //   new Command("edit")
+            //     .description("edit API user")
+            //     .requiredOption("-u, --uuid <uuid>", "UUID of the API user")
+            //     .requiredOption("-r, --roles <roles...>", "list of role uuids")
+            //     ).action(this.edit)
+            // )
+            .addCommand(new OutputFormatCommand(new Command("list").description("list all API user's")).action(this.list))
+            .addCommand(new OutputFormatCommand(new Command("get")
+            .description("Retrieve an API user by UUID")
+            .requiredOption("-u, --uuid <uuid>", "UUID of the API user")).action(this.get)));
+    }
+    async newSecret(opts) {
+        const { uuid } = opts;
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const secret = await client.newSecret(uuid);
+        return secret;
+    }
+    async revokeSecret(opts) {
+        const { uuid } = opts;
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const status = await client.revokeSecret(uuid);
+        return status;
+    }
+    async getAuthToken(opts) {
+        const { user, password } = opts;
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const auth = await client.apiAuth(user, password);
+        return auth.data.Token;
+    }
+    async edit(opts) {
+        const { uuid, roles } = opts;
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const updatedUser = await client.edit(uuid, roles);
+        return updatedUser;
+    }
+    async list() {
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const users = await client.list();
+        return users;
+    }
+    async get(opts) {
+        const { uuid } = opts;
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const user = await client.get(uuid);
+        return user;
+    }
+}
+export default new ApiUsersCommand();

package/dist/commands/apps.js

@@ -0,0 +1,188 @@
+import { Command, Option } from "commander";
+import util from "../lib/util.js";
+import Api from "protokol-sdk";
+import { build, createServer } from 'vite';
+import { c } from 'tar';
+import { Writable } from "stream";
+import { writeFileSync } from "fs";
+import Util from "../lib/util.js";
+import Playground from "../playground.js";
+import { join } from 'path';
+class AppsCommand {
+    register() {
+        return new Command("apps")
+            .description("Manage apps")
+            .version("0.1.0")
+            .addCommand(new Command("download")
+            .description("Download app")
+            .addOption(new Option("-a, --apptype <apptype>", "App type to manage")
+            .choices(["app", "public-app"])
+            .makeOptionMandatory())
+            .requiredOption("-v, --version <version>", "App version to download")
+            .requiredOption("-r, --ref <ref>", "App's identifier")
+            .requiredOption("-o, --output <output>", "Download directory relative path")
+            .action(this.download))
+            .addCommand(new Command("upload")
+            .description("Upload app")
+            .addOption(new Option("-a, --apptype <apptype>", "App type to manage")
+            .choices(["app", "public-app", "portal"])
+            .makeOptionMandatory())
+            .requiredOption("-d, --directory <directory>", "App directory to upload")
+            .option("-b, --build", "Build app")
+            .action(this.upload))
+            .addCommand(new Command("deploy")
+            .description("Deploy app")
+            .addOption(new Option("-a, --apptype <apptype>", "App type to manage")
+            .choices(["app", "public-app", "portal"])
+            .makeOptionMandatory())
+            .requiredOption("-r, --ref <ref>", "App's identifier")
+            .option("-d, --dev_version <dev_version>", "Development version")
+            .option("-p, --public_version <public_version>", "Public version")
+            .action(this.deploy))
+            .addCommand(new Command("playground")
+            .description("Start playground")
+            .requiredOption("-p, --path <path>", "Path is directory where app is located.")
+            .option(" --port <port>", "WSS port")
+            .option("-s --sdk_version <sdk_version>", "SDK Version to be used for build", "5")
+            .option("-e --engine <engine>", "Engine to be used for build", "vue2")
+            .addOption(new Option("-a, --apptype <apptype>", "App type to manage")
+            .choices(["app", "public-app"])
+            .makeOptionMandatory())
+            .action(this.playground))
+            .addCommand(new Command("bundle")
+            .description("Bundle app")
+            .requiredOption("-p, --path <path>", "Path is directory where app is located.")
+            .option("-u, --upload", "Upload bundle")
+            .action(this.bundle))
+            .addCommand(new Command("dev")
+            .description("Run dev app")
+            .requiredOption("-p, --path <path>", "Path is directory where app is located.")
+            .action(this.runDev))
+            .addCommand(new Command("remove-version")
+            .description("Remove version from available versions of the app")
+            .requiredOption("-v, --version <version>")
+            .requiredOption("-r, --ref <ref>")
+            .action(this.removeVersion));
+    }
+    async download(options) {
+        const { apptype, version, ref, output } = options;
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).app(apptype);
+        return await client.download(version, ref, output);
+    }
+    async upload(options) {
+        const { apptype, directory, build } = options;
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).app(apptype);
+        return await client.upload(directory, build);
+    }
+    async deploy(options) {
+        const { apptype, dev_version, public_version, ref } = options;
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).app(apptype);
+        return await client.updateSettings({ dev_version, public_version }, ref);
+    }
+    async playground(options) {
+        let { path, port, sdk_version, engine, apptype } = options;
+        port = port ? Number(port) : 11400;
+        const profile = util.getCurrentProfile();
+        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).app();
+        let playgroundWatcher = new Playground(apptype, path, Number(sdk_version), engine, port, profile);
+        await playgroundWatcher.init();
+        playgroundWatcher.start();
+    }
+    async bundle(options) {
+        const { path, upload } = options;
+        const module = await import(`${path}/ptkl.config.js`);
+        const { views, name, version, distPath, icon, label, permissions, } = module.default ?? {};
+        // build manifest file
+        const manifest = {
+            name,
+            version,
+            views: {},
+            label,
+            icon,
+            permissions,
+        };
+        const profile = Util.getCurrentProfile();
+        const client = Util.getClientForProfile();
+        // get base url of the platform client
+        const baseUrl = client.getPlatformBaseURL();
+        const base = `${baseUrl}/v3/system/gateway/app-service/static/bundle/${profile.project}/${name}/${version}`;
+        manifest.icon = `${base}/${icon}`;
+        const buildViews = Object.keys(views).map((view) => {
+            manifest.views[view] = `${view}.bundle.js`;
+            return build({
+                root: path,
+                base,
+                build: {
+                    rollupOptions: {
+                        input: views[view],
+                        output: {
+                            format: 'umd',
+                            entryFileNames: `${view}.bundle.js`,
+                        }
+                    }
+                }
+            });
+        });
+        await Promise.allSettled(buildViews).catch(err => {
+            console.error('Error building:', err);
+        });
+        console.log("Packaging app...");
+        // // write manifest file
+        const manifestPath = `${distPath}/manifest.json`;
+        writeFileSync(manifestPath, JSON.stringify(manifest, null, 4));
+        if (upload) {
+            let buffer = Buffer.alloc(0);
+            const bufferStream = new Writable({
+                write(chunk, encoding, callback) {
+                    buffer = Buffer.concat([buffer, chunk]);
+                    callback();
+                },
+            });
+            c({ gzip: true, cwd: distPath }, ['.']).pipe(bufferStream).on('finish', () => {
+                client.app().bundleUpload(buffer).then(() => {
+                    console.log('Bundle uploaded successfully');
+                })
+                    .catch((error) => {
+                    console.error('Bundle error:', error.response.data.message);
+                });
+            })
+                .on('error', (error) => {
+                console.error('Error creating the archive:', error.message);
+            });
+        }
+        else {
+            try {
+                await c({ gzip: true, cwd: distPath, file: join(distPath, `/../bundle-${manifest.version}.tar.gz`) }, ['.']);
+                console.log('Bundle created successfully');
+            }
+            catch (error) {
+                console.error('Error creating the archive:', error.message);
+            }
+        }
+    }
+    async runDev(options) {
+        const { path } = options;
+        const server = await createServer({
+            root: path, // Set your project root
+        });
+        await server.listen();
+        console.log('Dev server running at:', server?.resolvedUrls?.local[0]);
+    }
+    async removeVersion(options) {
+        const { version, ref } = options;
+        const profile = util.getClientForProfile();
+        const client = profile.app();
+        const { data } = await client.getApp(ref);
+        if (data.public_version === version) {
+            throw new Error("Cannot remove public version");
+        }
+        const settings = data.settings.filter((s) => s.version !== version);
+        return await client.updateSettings({
+            'settings': settings
+        }, ref);
+    }
+}
+export default new AppsCommand();

package/dist/commands/forge.js

@@ -0,0 +1,104 @@
+import { Command } from "commander";
+import { build, createServer } from 'vite';
+import { c } from 'tar';
+import { Writable } from "stream";
+import { writeFileSync } from "fs";
+import Util from "../lib/util.js";
+import { join } from 'path';
+class ForgeCommand {
+    register() {
+        return new Command("forge")
+            .description("Work with protokol forge to seamlessly build and deploy apps")
+            .version("0.1.0")
+            .addCommand(new Command("bundle")
+            .description("Bundle app")
+            .requiredOption("-p, --path <path>", "Path is directory where app is located.")
+            .option("-u, --upload", "Upload bundle")
+            .action(this.bundle))
+            .addCommand(new Command("dev")
+            .description("Run dev app")
+            .requiredOption("-p, --path <path>", "Path is directory where app is located.")
+            .action(this.runDev));
+    }
+    async bundle(options) {
+        const { path, upload } = options;
+        const module = await import(`${path}/ptkl.config.js`);
+        const { views, name, version, distPath, icon, label, permissions, } = module.default ?? {};
+        // build manifest file
+        const manifest = {
+            name,
+            version,
+            views: {},
+            label,
+            icon,
+            permissions,
+        };
+        const profile = Util.getCurrentProfile();
+        const client = Util.getClientForProfile();
+        // get base url of the platform client
+        const baseUrl = client.getPlatformBaseURL();
+        const base = `${baseUrl}/v3/system/gateway/app-service/forge/static/bundle/${profile.project}/${name}/${version}`;
+        manifest.icon = `${base}/${icon}`;
+        const buildViews = Object.keys(views).map((view) => {
+            manifest.views[view] = `${view}.bundle.js`;
+            return build({
+                root: path,
+                base,
+                build: {
+                    rollupOptions: {
+                        input: views[view],
+                        output: {
+                            format: 'umd',
+                            entryFileNames: `${view}.bundle.js`,
+                        }
+                    }
+                }
+            });
+        });
+        await Promise.allSettled(buildViews).catch(err => {
+            console.error('Error building:', err);
+        });
+        console.log("Packaging app...");
+        // // write manifest file
+        const manifestPath = `${distPath}/manifest.json`;
+        writeFileSync(manifestPath, JSON.stringify(manifest, null, 4));
+        if (upload) {
+            let buffer = Buffer.alloc(0);
+            const bufferStream = new Writable({
+                write(chunk, encoding, callback) {
+                    buffer = Buffer.concat([buffer, chunk]);
+                    callback();
+                },
+            });
+            c({ gzip: true, cwd: distPath }, ['.']).pipe(bufferStream).on('finish', () => {
+                client.forge().bundleUpload(buffer).then(() => {
+                    console.log('Bundle uploaded successfully');
+                })
+                    .catch((error) => {
+                    console.error('Bundle error:', error);
+                });
+            })
+                .on('error', (error) => {
+                console.error('Error creating the archive:', error.message);
+            });
+        }
+        else {
+            try {
+                await c({ gzip: true, cwd: distPath, file: join(distPath, `/../bundle-${manifest.version}.tar.gz`) }, ['.']);
+                console.log('Bundle created successfully');
+            }
+            catch (error) {
+                console.error('Error creating the archive:', error.message);
+            }
+        }
+    }
+    async runDev(options) {
+        const { path } = options;
+        const server = await createServer({
+            root: path, // Set your project root
+        });
+        await server.listen();
+        console.log('Dev server running at:', server?.resolvedUrls?.local[0]);
+    }
+}
+export default new ForgeCommand();