@nocobase/plugin-flow-engine 2.0.0-alpha.2

package/dist/server/template/resolver.js

@@ -0,0 +1,225 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolver_exports = {};
+__export(resolver_exports, {
+  preprocessExpression: () => preprocessExpression,
+  resolveJsonTemplate: () => resolveJsonTemplate
+});
+module.exports = __toCommonJS(resolver_exports);
+var import_ses = require("ses");
+var import_lodash = __toESM(require("lodash"));
+async function resolveJsonTemplate(template, ctx) {
+  const compile = async (source) => {
+    if (typeof source === "string" && /\{\{.*?\}\}/.test(source)) {
+      return await replacePlaceholders(source, ctx);
+    }
+    if (Array.isArray(source)) return Promise.all(source.map(compile));
+    if (source && typeof source === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(source)) out[k] = await compile(v);
+      return out;
+    }
+    return source;
+  };
+  return compile(template);
+}
+async function replacePlaceholders(input, ctx) {
+  const single = input.match(/^\{\{\s*(.+)\s*\}\}$/);
+  if (single) {
+    const val = await evaluate(single[1], ctx);
+    return typeof val === "undefined" ? input : val;
+  }
+  const regex = /\{\{\s*(.+?)\s*\}\}/g;
+  let result = input;
+  const matches = [...input.matchAll(regex)];
+  for (const [full, inner] of matches) {
+    const value = await evaluate(inner, ctx);
+    if (typeof value !== "undefined") {
+      const replacement = typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+      result = result.replace(full, replacement);
+    }
+  }
+  return result;
+}
+async function evaluate(expr, ctx) {
+  try {
+    const raw = expr.trim();
+    const dotOnly = raw.match(/^ctx\.([a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*)$/);
+    if (dotOnly) {
+      const path = dotOnly[1];
+      const segs = path.split(".");
+      const first = segs.shift();
+      const base = await ctx[first];
+      if (!segs.length) return base;
+      return await asyncGetValuesByPath(base, segs.join("."));
+    }
+    const transformed = preprocessExpression(raw);
+    const compartment = new Compartment({
+      ctx,
+      __get: (varName, path) => getAtPath(ctx, varName, path),
+      console
+    });
+    const wrapped = `(async () => { try { return ${transformed}; } catch (e) { return undefined; } })()`;
+    return await compartment.evaluate(wrapped);
+  } catch (_2) {
+    return void 0;
+  }
+}
+async function getAtPath(ctx, varName, path) {
+  try {
+    let current = await ctx[varName];
+    if (!path) return current;
+    const norm = String(path || "").replace(/^\./, "");
+    const segments = import_lodash.default.toPath(norm);
+    for (const seg of segments) {
+      if (current == null) return void 0;
+      let val = current[seg];
+      if (val && typeof val["then"] === "function") {
+        val = await val;
+      }
+      current = val;
+    }
+    return current;
+  } catch (_2) {
+    return void 0;
+  }
+}
+async function asyncGetValuesByPath(obj, path, defaultValue) {
+  try {
+    let currentValue = await obj;
+    if (!currentValue) return defaultValue;
+    const keys = String(path || "").split(".");
+    let result = [];
+    let shouldReturnArray = false;
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (Array.isArray(currentValue)) {
+        shouldReturnArray = true;
+        const rest = keys.slice(i).join(".");
+        const parts = await Promise.all(currentValue.map((el) => asyncGetValuesByPath(el, rest, defaultValue)));
+        for (const p of parts) {
+          if (Array.isArray(p)) result.push(...p);
+          else if (typeof p !== "undefined") result.push(p);
+        }
+        break;
+      }
+      let val = currentValue == null ? void 0 : currentValue[key];
+      if (val && typeof val.then === "function") {
+        val = await val;
+      }
+      currentValue = val;
+      if (i === keys.length - 1) {
+        result.push(currentValue);
+      }
+    }
+    result = result.filter((item) => typeof item !== "undefined");
+    if (result.length === 0) return defaultValue;
+    if (shouldReturnArray) return result.filter((item) => item !== null);
+    return result[0];
+  } catch (_2) {
+    return defaultValue;
+  }
+}
+function preprocessExpression(expression) {
+  let out = "";
+  let i = 0;
+  const n = expression.length;
+  while (i < n) {
+    const dotIdx = expression.indexOf("ctx.", i);
+    const brkIdx = expression.indexOf("ctx[", i);
+    let idx = -1;
+    if (dotIdx === -1) idx = brkIdx;
+    else if (brkIdx === -1) idx = dotIdx;
+    else idx = Math.min(dotIdx, brkIdx);
+    if (idx === -1) {
+      out += expression.slice(i);
+      break;
+    }
+    out += expression.slice(i, idx);
+    let j = idx + 3;
+    let varName = null;
+    let pathStr = "";
+    if (expression[j] === ".") {
+      j += 1;
+      const varMatch = /^[a-zA-Z_$][a-zA-Z0-9_$]*/.exec(expression.slice(j));
+      if (!varMatch) {
+        out += "ctx.";
+        i = j;
+        continue;
+      }
+      varName = varMatch[0];
+      j += varName.length;
+    } else if (expression[j] === "[") {
+      const m = /^\[("((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)')\]/.exec(expression.slice(j));
+      if (!m) {
+        out += "ctx[";
+        i = j;
+        continue;
+      }
+      varName = m[2] ?? m[3];
+      j += m[0].length;
+    } else {
+      out += expression.slice(idx, idx + 3);
+      i = idx + 3;
+      continue;
+    }
+    while (j < n) {
+      if (expression[j] === ".") {
+        const m = /^\.[a-zA-Z_$][a-zA-Z0-9_$]*/.exec(expression.slice(j));
+        if (!m) break;
+        pathStr += m[0];
+        j += m[0].length;
+      } else if (expression[j] === "[") {
+        const m = /^(\[(?:\d+|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\])/.exec(expression.slice(j));
+        if (!m) break;
+        pathStr += m[1];
+        j += m[1].length;
+      } else {
+        break;
+      }
+    }
+    const argPath = pathStr ? `, ${JSON.stringify(pathStr)}` : "";
+    out += `(await __get(${JSON.stringify(varName)}${argPath}))`;
+    i = j;
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  preprocessExpression,
+  resolveJsonTemplate
+});

package/dist/server/variables/registry.d.ts

@@ -0,0 +1,42 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { HttpRequestContext } from '../template/contexts';
+import { ResourcerContext } from '@nocobase/resourcer';
+export type JSONValue = string | {
+    [key: string]: JSONValue;
+} | JSONValue[];
+export type VarScope = 'global' | 'request';
+export interface RequiredParamSpec {
+    name: string;
+    required?: boolean;
+    defaultValue?: any;
+}
+export interface VariableDef {
+    name: string;
+    scope: VarScope;
+    requiredParams?: RequiredParamSpec[];
+    attach: (ctx: HttpRequestContext, koaCtx: ResourcerContext, params?: any, usage?: VarUsage) => Promise<void> | void;
+}
+export type VarUsage = {
+    [varName: string]: string[];
+};
+declare class VariableRegistry {
+    private vars;
+    register(def: VariableDef): void;
+    get(name: string): VariableDef;
+    list(): VariableDef[];
+    extractUsage(template: JSONValue): VarUsage;
+    validate(template: JSONValue, contextParams: any): {
+        ok: boolean;
+        missing?: string[];
+    };
+    attachUsedVariables(ctx: HttpRequestContext, koaCtx: ResourcerContext, template: JSONValue, contextParams: any): Promise<void>;
+}
+export declare const variables: VariableRegistry;
+export {};

package/dist/server/variables/registry.js

@@ -0,0 +1,299 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registry_exports = {};
+__export(registry_exports, {
+  variables: () => variables
+});
+module.exports = __toCommonJS(registry_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_contexts = require("../template/contexts");
+var import_utils = require("@nocobase/utils");
+class VariableRegistry {
+  vars = /* @__PURE__ */ new Map();
+  register(def) {
+    this.vars.set(def.name, def);
+  }
+  get(name) {
+    return this.vars.get(name);
+  }
+  list() {
+    return Array.from(this.vars.values());
+  }
+  extractUsage(template) {
+    return (0, import_utils.extractUsedVariablePaths)(template);
+  }
+  validate(template, contextParams) {
+    var _a;
+    const usage = this.extractUsage(template);
+    const missing = [];
+    for (const varName of Object.keys(usage)) {
+      const def = this.get(varName);
+      if (!((_a = def == null ? void 0 : def.requiredParams) == null ? void 0 : _a.length)) continue;
+      const params = import_lodash.default.get(contextParams, varName);
+      for (const spec of def.requiredParams) {
+        if (!spec.required) continue;
+        if (params && typeof params[spec.name] !== "undefined") continue;
+        missing.push(`contextParams.${varName}.${spec.name}`);
+      }
+    }
+    return { ok: missing.length === 0, missing: missing.length ? missing : void 0 };
+  }
+  async attachUsedVariables(ctx, koaCtx, template, contextParams) {
+    const usage = this.extractUsage(template);
+    for (const varName of Object.keys(usage)) {
+      const def = this.get(varName);
+      const params = import_lodash.default.get(contextParams, varName);
+      if (def) {
+        await def.attach(ctx, koaCtx, params, { [varName]: usage[varName] });
+      }
+    }
+    attachGenericRecordVariables(ctx, koaCtx, usage, contextParams);
+  }
+}
+const GLOBAL_KEY = "__ncbVarRegistry__";
+const g = typeof globalThis !== "undefined" ? globalThis : global;
+if (!g[GLOBAL_KEY]) {
+  g[GLOBAL_KEY] = new VariableRegistry();
+}
+const variables = g[GLOBAL_KEY];
+function inferSelectsFromUsage(paths = [], params) {
+  if (!Array.isArray(paths) || paths.length === 0) {
+    return { generatedAppends: void 0, generatedFields: void 0 };
+  }
+  const appendSet = /* @__PURE__ */ new Set();
+  const fieldSet = /* @__PURE__ */ new Set();
+  for (let path of paths) {
+    if (!path) continue;
+    while (/^\[(\d+)\](\.|$)/.test(path)) {
+      path = path.replace(/^\[(\d+)\]\.?/, "");
+    }
+    if (!path) continue;
+    let first = "";
+    let rest = "";
+    const mStr = path.match(/^\[(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)')\](.*)$/);
+    if (mStr) {
+      first = (mStr[1] ?? mStr[2]) || "";
+      rest = mStr[3] || "";
+    } else {
+      const m = path.match(/^([^.[]+)([\s\S]*)$/);
+      first = (m == null ? void 0 : m[1]) ?? "";
+      rest = (m == null ? void 0 : m[2]) ?? "";
+    }
+    if (!first) continue;
+    const hasDeep = rest.includes(".") || rest.includes("[");
+    if (hasDeep) appendSet.add(first);
+    else fieldSet.add(first);
+  }
+  const generatedAppends = appendSet.size ? Array.from(appendSet) : void 0;
+  const generatedFields = fieldSet.size ? Array.from(fieldSet) : void 0;
+  return { generatedAppends, generatedFields };
+}
+async function fetchRecordWithRequestCache(koaCtx, dataSourceKey, collection, filterByTk, fields, appends) {
+  try {
+    const kctx = koaCtx;
+    if (!kctx.state) kctx.state = {};
+    if (!kctx.state["__varResolveBatchCache"]) {
+      kctx.state["__varResolveBatchCache"] = /* @__PURE__ */ new Map();
+    }
+    const cache = kctx.state.__varResolveBatchCache || null;
+    const ds = koaCtx.app.dataSourceManager.get(dataSourceKey || "main");
+    const cm = ds.collectionManager;
+    if (!(cm == null ? void 0 : cm.db)) return void 0;
+    const repo = cm.db.getRepository(collection);
+    const keyObj = {
+      ds: dataSourceKey || "main",
+      c: collection,
+      tk: filterByTk,
+      f: Array.isArray(fields) ? [...fields].sort() : void 0,
+      a: Array.isArray(appends) ? [...appends].sort() : void 0
+    };
+    const key = JSON.stringify(keyObj);
+    if (cache) {
+      if (cache.has(key)) return cache.get(key);
+      const needFields = Array.isArray(fields) ? new Set(fields) : void 0;
+      const needAppends = Array.isArray(appends) ? new Set(appends) : void 0;
+      let fallbackAny = void 0;
+      for (const [cacheKey, cacheVal] of cache.entries()) {
+        const parsed = JSON.parse(cacheKey);
+        if (!parsed || parsed.ds !== keyObj.ds || parsed.c !== keyObj.c || parsed.tk !== keyObj.tk) continue;
+        const cachedFields = Array.isArray(parsed.f) ? new Set(parsed.f) : void 0;
+        const cachedAppends = Array.isArray(parsed.a) ? new Set(parsed.a) : void 0;
+        const fieldsOk = !needFields || cachedFields && [...needFields].every((x) => cachedFields.has(x));
+        const appendsOk = !needAppends || cachedAppends && [...needAppends].every((x) => cachedAppends.has(x));
+        if (fieldsOk && appendsOk) return cacheVal;
+        if (typeof fallbackAny === "undefined") fallbackAny = cacheVal;
+      }
+      if (typeof fallbackAny !== "undefined") return fallbackAny;
+    }
+    const tk = filterByTk;
+    const rec = await repo.findOne({
+      filterByTk: tk,
+      fields,
+      appends
+    });
+    const json = rec ? rec.toJSON() : void 0;
+    if (cache) cache.set(key, json);
+    return json;
+  } catch (_2) {
+    return void 0;
+  }
+}
+function isRecordParams(val) {
+  return val && typeof val === "object" && "collection" in val && "filterByTk" in val;
+}
+function attachGenericRecordVariables(flowCtx, koaCtx, usage, contextParams) {
+  const parseIndexSegment = (segment) => {
+    const m = segment.match(/^\[(\d+)\]$/);
+    return m ? m[1] : void 0;
+  };
+  for (const varName of Object.keys(usage)) {
+    const usedPaths = usage[varName] || [];
+    const topParams = import_lodash.default.get(contextParams, varName);
+    if (isRecordParams(topParams)) {
+      const { generatedAppends, generatedFields } = inferSelectsFromUsage(usedPaths, topParams);
+      flowCtx.defineProperty(varName, {
+        get: async () => {
+          const dataSourceKey = (topParams == null ? void 0 : topParams.dataSourceKey) || "main";
+          return await fetchRecordWithRequestCache(
+            koaCtx,
+            dataSourceKey,
+            topParams.collection,
+            topParams.filterByTk,
+            generatedFields,
+            generatedAppends
+          );
+        },
+        cache: true
+      });
+      continue;
+    }
+    const segmentMap = /* @__PURE__ */ new Map();
+    const splitHead = (path) => {
+      if (!path) return { seg: "", remainder: "" };
+      const mIdx = path.match(/^\[(\d+)\](?:\.(.*))?$/);
+      if (mIdx) {
+        return { seg: `[${mIdx[1]}]`, remainder: mIdx[2] || "" };
+      }
+      const m = path.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)(\[(?:\d+|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\])?(?:\.(.*))?$/);
+      if (m) {
+        const seg2 = m[1];
+        const idxPart = m[2] || "";
+        const tail = m[3] || "";
+        const remainder = (idxPart ? `${idxPart}${tail ? `.${tail}` : ""}` : tail) || "";
+        return { seg: seg2, remainder };
+      }
+      const [seg, ...rest] = path.split(".");
+      return { seg, remainder: rest.join(".") };
+    };
+    for (const p of usedPaths) {
+      if (!p) continue;
+      const { seg, remainder } = splitHead(p);
+      if (!seg) continue;
+      const arr = segmentMap.get(seg) || [];
+      arr.push(remainder);
+      segmentMap.set(seg, arr);
+    }
+    const segEntries = Array.from(segmentMap.entries());
+    const recordChildren = segEntries.filter(([seg]) => {
+      const idx = parseIndexSegment(seg);
+      const nestedObj = import_lodash.default.get(contextParams, [varName, seg]) ?? (idx ? import_lodash.default.get(contextParams, [varName, idx]) : void 0);
+      const dotted = (contextParams || {})[`${varName}.${seg}`] ?? (idx ? (contextParams || {})[`${varName}.${idx}`] : void 0);
+      return isRecordParams(nestedObj) || isRecordParams(dotted);
+    });
+    if (!recordChildren.length) continue;
+    flowCtx.defineProperty(varName, {
+      get: () => {
+        const subContext = new import_contexts.ServerBaseContext();
+        for (const [seg, remainders] of recordChildren) {
+          const idx = parseIndexSegment(seg);
+          const recordParams = import_lodash.default.get(contextParams, [varName, seg]) ?? (idx ? import_lodash.default.get(contextParams, [varName, idx]) : void 0) ?? (contextParams || {})[`${varName}.${seg}`] ?? (idx ? (contextParams || {})[`${varName}.${idx}`] : void 0);
+          let effRemainders = remainders.filter((r) => !!r);
+          if (!effRemainders.length) {
+            const all = usedPaths.map(
+              (p) => p.startsWith(`${seg}.`) ? p.slice(seg.length + 1) : p.startsWith(`${seg}[`) ? p.slice(seg.length) : ""
+            ).filter((x) => !!x);
+            if (all.length) effRemainders = all;
+          }
+          const { generatedAppends, generatedFields } = inferSelectsFromUsage(effRemainders, recordParams);
+          const definitionKey = idx ?? seg;
+          subContext.defineProperty(definitionKey, {
+            get: async () => {
+              const dataSourceKey = (recordParams == null ? void 0 : recordParams.dataSourceKey) || "main";
+              return await fetchRecordWithRequestCache(
+                koaCtx,
+                dataSourceKey,
+                recordParams.collection,
+                recordParams.filterByTk,
+                generatedFields,
+                generatedAppends
+              );
+            },
+            cache: true
+          });
+        }
+        return subContext.createProxy();
+      },
+      cache: true
+    });
+  }
+}
+function registerBuiltInVariables(reg) {
+  reg.register({
+    name: "user",
+    scope: "request",
+    // no requiredParams: frontend will not pass context params for user
+    attach: (flowCtx, koaCtx, _params, usage) => {
+      const paths = (usage == null ? void 0 : usage["user"]) || [];
+      const { generatedAppends, generatedFields } = inferSelectsFromUsage(paths);
+      flowCtx.defineProperty("user", {
+        get: async () => {
+          var _a;
+          const authObj = koaCtx.auth;
+          const uid = (_a = authObj == null ? void 0 : authObj.user) == null ? void 0 : _a.id;
+          if (typeof uid === "undefined" || uid === null) return void 0;
+          return await fetchRecordWithRequestCache(koaCtx, "main", "users", uid, generatedFields, generatedAppends);
+        },
+        cache: true
+      });
+    }
+  });
+}
+registerBuiltInVariables(variables);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  variables
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@nocobase/plugin-flow-engine",
+  "displayName": "Flow engine",
+  "displayName.zh-CN": "前端流引擎",
+  "description": "",
+  "description.zh-CN": "",
+  "version": "2.0.0-alpha.2",
+  "main": "./dist/server/index.js",
+  "license": "AGPL-3.0",
+  "devDependencies": {
+    "antd": "5.x",
+    "cronstrue": "^2.11.0",
+    "koa-send": "^5.0.1",
+    "koa-static": "^5.0.0"
+  },
+  "dependencies": {
+    "ses": "^1.14.0"
+  },
+  "peerDependencies": {
+    "@nocobase/client": "2.x",
+    "@nocobase/database": "2.x",
+    "@nocobase/plugin-localization": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/test": "2.x",
+    "@nocobase/utils": "2.x"
+  },
+  "gitHead": "1322f486b248bef53ed8c8f42f0a39dfd02125fd"
+}

package/server.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/server';
+export { default } from './dist/server';

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');