oc-server 0.4.5 → 1.1.0

package/dist/Server.d.ts

@@ -1,23 +1,41 @@
 import { DataContext, DataProvider } from './types';
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 export type ServerContext<E = {
     name: string;
-}, P = any> = Omit<DataContext<any, E, P>, 'params' | 'action' | 'setEmptyResponse'>;
-export type Action<I, O, E> = (params: I, ctx: ServerContext<E>) => Promise<O> | O;
-type AnyAction = Action<any, any, any>;
-export declare class Server<E, A extends Record<string, AnyAction> = {}, InitialInput = any, InitialOutput = any> {
-    readonly initial: Action<InitialInput, InitialOutput, E>;
+}, P = any, S = any> = Omit<DataContext<any, E, P, S>, 'params' | 'action' | 'setEmptyResponse'>;
+export type Action<I, O, E, P, S> = (params: I, ctx: ServerContext<E, P, S>) => Promise<O> | O;
+type AnyAction = Action<any, any, any, any, any>;
+type IsGeneralStringName<T> = T extends {
+    name: infer N;
+} ? N extends string ? string extends N ? true : false : false : false;
+export declare class Server<E = {
+    name: string;
+}, P = unknown, A extends Record<string, AnyAction> = {}, InitialInput = any, InitialOutput = any, MiddlewareInput = any, MiddlewareOutput = any> {
+    private _middleware;
+    constructor();
+    middleware<I, O>(action: Action<I, O, E, P, unknown>): Omit<Server<E, P, A, InitialInput, InitialOutput, I, O>, P extends Record<string, unknown> ? IsGeneralStringName<E> extends false ? 'middleware' | 'definePlugins' | 'defineEnv' : 'middleware' | 'definePlugins' : IsGeneralStringName<E> extends false ? 'middleware' | 'defineEnv' : 'middleware'>;
+    defineEnv<Env>(): P extends Record<string, any> ? Omit<Server<Env, P, A, InitialInput, InitialOutput>, 'defineEnv' | 'definePlugins'> : Omit<Server<Env, P, A, InitialInput, InitialOutput>, 'defineEnv'>;
+    definePlugins<Plugins>(): IsGeneralStringName<E> extends true ? Omit<Server<E, Plugins, A, InitialInput, InitialOutput>, 'definePlugins'> : Omit<Server<E, Plugins, A, InitialInput, InitialOutput>, 'definePlugins' | 'defineEnv'>;
+    handler<I, O>(action: Action<I, O, E, P, MiddlewareOutput>): HandledServer<E, P, A, I, O, MiddlewareInput, MiddlewareOutput>;
+}
+declare class HandledServer<E, P, A extends Record<string, AnyAction> = {}, InitialInput = any, InitialOutput = any, MiddlewareInput = any, MiddlewareOutput = any> {
+    readonly initial: Action<InitialInput, InitialOutput, E, P, MiddlewareOutput>;
+    private readonly _middleware;
     readonly actions: A;
-    constructor(initial: Action<InitialInput, InitialOutput, E>);
-    action<ActionName extends string, I, O>(name: ActionName, action: Action<I, O, E>): Server<E, A & Record<ActionName, Action<I, O, E>>, InitialInput, InitialOutput>;
+    constructor(initial: Action<InitialInput, InitialOutput, E, P, MiddlewareOutput>, _middleware?: Action<MiddlewareInput, MiddlewareOutput, E, P, unknown> | null);
+    action<ActionName extends string, I, O>(name: ActionName, action: Action<I, O, E, P, MiddlewareOutput>): HandledServer<E, P, Prettify<A & Record<ActionName, Action<I, O, E, P, MiddlewareOutput>>>, InitialInput, InitialOutput, MiddlewareInput, MiddlewareOutput>;
     getData(): DataProvider<any, any, any>;
 }
 export interface Register {
 }
-export type AnyServer = Server<any, any>;
+export type AnyServer = HandledServer<any, any>;
 export type RegisteredServer = Register extends {
     server: infer TServer extends AnyServer;
 } ? TServer : AnyServer;
-type GetInitialData<TServer extends AnyServer> = TServer extends Server<any, any, any, infer O> ? Exclude<O, undefined | null> : any;
+export type GetMiddlewareInput<TServer extends AnyServer> = TServer extends HandledServer<any, any, any, any, any, infer I> ? I : any;
+type GetInitialData<TServer extends AnyServer> = TServer extends HandledServer<any, any, any, any, infer O> ? Exclude<O, undefined | null> : any;
 export type InitialData = GetInitialData<RegisteredServer>;
 export type ComponentSettings = {
     id: string;

package/dist/Server.js

@@ -2,10 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSettings = exports.getInitialData = exports.Server = void 0;
 class Server {
+    _middleware = null;
+    constructor() { }
+    middleware(action) {
+        this._middleware = action;
+        return this;
+    }
+    defineEnv() {
+        return this;
+    }
+    definePlugins() {
+        return this;
+    }
+    handler(action) {
+        return new HandledServer(action, this._middleware);
+    }
+}
+exports.Server = Server;
+class HandledServer {
     initial;
+    _middleware;
     actions = {};
-    constructor(initial) {
+    constructor(initial, _middleware = null) {
         this.initial = initial;
+        this._middleware = _middleware;
     }
     action(name, action) {
         this.actions[name] = action;
@@ -15,6 +35,10 @@ class Server {
         return async ({ action: actionName, params, setEmptyResponse, ...context }, cb) => {
             let res;
             try {
+                if (this._middleware) {
+                    const data = await this._middleware(params, context);
+                    context.state = data;
+                }
                 if (actionName && this.actions[actionName]) {
                     const data = params?.data ?? params;
                     res = await this.actions[actionName](data, context);
@@ -31,7 +55,6 @@ class Server {
         };
     }
 }
-exports.Server = Server;
 const getInitialData = () => typeof __$$oc_initialData__ !== 'undefined'
     ? __$$oc_initialData__
     : {};

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/dist/serverClient.d.ts

@@ -1,8 +1,13 @@
-import { AnyServer, RegisteredServer, Action } from './Server';
-type InferInput<R> = R extends Action<infer I, any, any> ? I : any;
-type InferOutput<R> = R extends Action<any, infer O, any> ? O : never;
+import { AnyServer, RegisteredServer, Action, GetMiddlewareInput } from './Server';
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+type IsAny<T> = IfAny<T, true, never>;
+type InferInput<R> = R extends Action<infer I, any, any, any, any> ? I : any;
+type InferOutput<R> = R extends Action<any, infer O, any, any, any> ? O : never;
 type ServerClient<TServer extends AnyServer> = {
-    readonly [Property in keyof TServer['actions']]: (input: InferInput<TServer['actions'][Property]>) => Promise<InferOutput<TServer['actions'][Property]>>;
+    readonly [Property in keyof TServer['actions']]: (input: Prettify<InferInput<TServer['actions'][Property]> & (IsAny<GetMiddlewareInput<TServer>> extends never ? GetMiddlewareInput<TServer> : {})>) => Promise<InferOutput<TServer['actions'][Property]>>;
 };
 export declare const serverClient: ServerClient<RegisteredServer>;
 export type ActionOutput<K extends keyof typeof serverClient> = Awaited<ReturnType<(typeof serverClient)[K]>>;

package/dist/types.d.ts

@@ -17,7 +17,7 @@ export interface Template {
     version: string;
     externals: External[];
 }
-export interface DataContext<T = any, E = Env, P = any> {
+export type DataContext<T = any, E = Env, P = any, S = unknown> = {
     action?: string;
     acceptLanguage: AcceptLanguage[];
     baseUrl: string;
@@ -30,7 +30,9 @@ export interface DataContext<T = any, E = Env, P = any> {
     setHeader: (header: string, value: string) => void;
     staticPath: string;
     templates: Template[];
-}
+} & (S extends Record<string, unknown> ? {
+    state: S;
+} : {});
 type Callback<D, E = Error> = (error: E | null, data?: D) => void;
 export type DataProvider<Parameters = any, Return = any, Environment = Env> = (context: DataContext<Parameters, Environment>, callback: Callback<Return>) => void;
 export {};

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "oc-server",
-  "version": "0.4.5",
+  "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"
+  }
+}