oc-server 1.0.0 → 1.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+process.env.VITE_CJS_IGNORE_WARNING = 'true';
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_vm_1 = __importDefault(require("node:vm"));
+const express_1 = __importDefault(require("express"));
+const vite_1 = require("vite");
+const esbuild_1 = __importDefault(require("esbuild"));
+const oc_client_browser_1 = __importDefault(require("oc-client-browser"));
+const cssModulesPlugin_1 = __importDefault(require("oc-vite-compiler/dist/lib/cssModulesPlugin"));
+const get_mocked_plugins_js_1 = __importDefault(require("oc/dist/cli/domain/get-mocked-plugins.js"));
+const node_util_1 = require("node:util");
+const promisify = (fn) => (...args) => new Promise((resolve, reject) => fn(...args, (err, data) => (err ? reject(err) : resolve(data))));
+const plugins = (0, get_mocked_plugins_js_1.default)({ err: () => { }, log: () => { }, ok: () => { }, warn: () => { } }, process.cwd());
+const pkg = require(node_path_1.default.join(process.cwd(), 'package.json'));
+const serverEntry = pkg.oc?.files?.data;
+let appEntry = pkg.oc?.files?.template?.src || '';
+if (!appEntry) {
+    console.log('Missing an entry on your package.json under oc.files.template.src');
+    process.exit(1);
+}
+if (!appEntry.startsWith('/')) {
+    appEntry = `/${appEntry}`;
+}
+const defaultParams = (() => {
+    let params = {};
+    if (pkg.oc?.parameters) {
+        params = Object.fromEntries(Object.entries(pkg.oc.parameters || {})
+            .filter(([, param]) => {
+            return !!param.mandatory && 'example' in param;
+        })
+            .map(([paramName, param]) => [paramName, param.example]));
+    }
+    return params;
+})();
+function getDataProvider() {
+    if (!serverEntry) {
+        return async (context) => ({ ...(context.params ?? {}) });
+    }
+    const result = esbuild_1.default.buildSync({
+        entryPoints: [serverEntry],
+        bundle: true,
+        format: 'cjs',
+        write: false,
+    });
+    const code = result.outputFiles[0].text;
+    const backend = node_vm_1.default.runInNewContext(code, {
+        ...globalThis,
+        exports: {},
+        module: { exports: {} },
+    });
+    const dataProvider = backend.data || backend.server.getData();
+    return promisify(dataProvider);
+}
+function getContext(req, params, action) {
+    const responseHeaders = {};
+    const context = {
+        action,
+        acceptLanguage: req.headers['accept-language'],
+        easeUrl: '/',
+        env: { name: 'local' },
+        params,
+        plugins,
+        renderComponent: () => {
+            throw new Error('renderComponent is not implemented in the server context');
+        },
+        renderComponents: () => {
+            throw new Error('renderComponents is not implemented in the server context');
+        },
+        requestHeaders: req.headers,
+        requestIp: req.ip,
+        setEmptyResponse: null,
+        staticPath: '/',
+        setHeader: (header, value) => {
+            if (!(typeof header === 'string' && typeof value === 'string')) {
+                throw new Error('context.setHeader parameters must be strings');
+            }
+            if (header && value) {
+                responseHeaders[header.toLowerCase()] = value;
+            }
+        },
+        templates: 'repository.getTemplatesInfo()',
+    };
+    return { context, responseHeaders };
+}
+function getBaseTemplate(appBlock) {
+    const baseTemplate = `
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta name="robots" content="index, follow" />
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <style>
+    html, body {
+      width: 100%;
+      height: 100%;
+      margin: 0;
+    };
+    </style>
+  </head>
+  <body>
+    <script src="/oc-client/client.js"></script>
+    ${appBlock({ name: pkg.name, version: pkg.version, entry: appEntry })}
+  </body>
+</html>
+  `;
+    return baseTemplate;
+}
+async function getHtmlTemplate(appBlock, filePath = 'index.html') {
+    let template;
+    try {
+        template = node_fs_1.default.readFileSync(node_path_1.default.resolve(process.cwd(), filePath), 'utf-8');
+        if (!template.includes('</body>')) {
+            throw new Error('If you use a custom html entry it has to have a closing body tag');
+        }
+        template = template.replace('</body>', `${appBlock}</body>`);
+    }
+    catch (error) {
+        template = getBaseTemplate(appBlock);
+    }
+    return template;
+}
+async function createServer({ template, port, }) {
+    const { dev: clientJs } = oc_client_browser_1.default.compileSync();
+    const app = (0, express_1.default)();
+    const dataProvider = getDataProvider();
+    app.use(express_1.default.json());
+    const vite = await (0, vite_1.createServer)({
+        server: { middlewareMode: true },
+        // @ts-ignore
+        plugins: [(0, cssModulesPlugin_1.default)(), template.plugin()],
+        mode: 'development',
+        optimizeDeps: {
+            exclude: ['fsevents'],
+        },
+        appType: 'custom',
+    });
+    app.use(vite.middlewares);
+    app.get('/oc-client/client.js', (req, res) => {
+        res.status(200).set({ 'Content-Type': 'text/javascript' }).send(clientJs);
+    });
+    app.post('/', async (req, res, next) => {
+        try {
+            const { action, parameters } = req.body.components[0];
+            const { context, responseHeaders } = getContext(req, parameters, action);
+            const props = await dataProvider(context);
+            const response = [
+                {
+                    status: 200,
+                    response: {
+                        data: {
+                            component: {
+                                props,
+                            },
+                        },
+                    },
+                },
+            ];
+            if (Object.keys(responseHeaders).length) {
+                res.set(responseHeaders);
+            }
+            res
+                .status(200)
+                .set({ 'Content-Type': 'application/json' })
+                .send(response);
+        }
+        catch (e) {
+            vite.ssrFixStacktrace(e);
+            next(e);
+        }
+    });
+    app.use('*', async (req, res, next) => {
+        const url = req.originalUrl;
+        try {
+            const params = defaultParams;
+            const { context, responseHeaders } = getContext(req, params);
+            let htmlTemplate = await getHtmlTemplate(template.appBlock);
+            const data = await dataProvider(context);
+            htmlTemplate = htmlTemplate.replace('__INITIAL_DATA__', JSON.stringify(data));
+            htmlTemplate = await vite.transformIndexHtml(url, htmlTemplate);
+            if (Object.keys(responseHeaders).length) {
+                res.set(responseHeaders);
+            }
+            res.status(200).set({ 'Content-Type': 'text/html' }).end(htmlTemplate);
+        }
+        catch (e) {
+            vite.ssrFixStacktrace(e);
+            next(e);
+        }
+    });
+    app.listen(port);
+    console.log(`Listening on: http://localhost:${port}`);
+}
+const major = Number(process.versions.node.split('.')[0]) || 0;
+if (major < 22) {
+    console.error('This script requires Node.js v22 or higher');
+    process.exit(1);
+}
+function cli(template) {
+    const { positionals: [command], values: { help, port = '5000' }, } = (0, node_util_1.parseArgs)({
+        allowPositionals: true,
+        options: {
+            port: {
+                type: 'string',
+                default: '5000',
+                short: 'p',
+            },
+            help: {
+                type: 'boolean',
+                default: false,
+                short: 'h',
+            },
+        },
+    });
+    if (help || !command) {
+        console.log(`
+    Usage:
+      $ oc-server <command> [options]
+
+    Commands:
+      dev         Start the development server
+
+    Options:
+      -h, --help  Display this message
+    `);
+        if (help && command === 'dev') {
+            console.log(`
+    Usage:
+      $ oc-server <command> [options]
+
+    Commands:
+      dev         Start the development server
+
+    Options:
+      -h, --help  Display this message
+      -p, --port  Port to use (default: 5000)
+    `);
+        }
+        process.exit(0);
+    }
+    if (command === 'dev') {
+        createServer({ template, port });
+    }
+}
+let template;
+try {
+    template = require(`${pkg.oc?.files?.template?.type}-compiler/dist/lib/hmr`);
+}
+catch (e) {
+    console.error(`The template ${pkg.oc?.files?.template?.type} is not supported. Try updating to the last version`);
+    process.exit(1);
+}
+cli(template);

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "oc-server",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "bin": "dist/cli.js",
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
@@ -19,5 +20,11 @@
   "files": [
     "dist/**"
   ],
-  "license": "MIT"
-}
+  "license": "MIT",
+  "dependencies": {
+    "oc": "^0.49.57"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21"
+  }
+}