@swarm.ing/pieui 2.1.6 → 2.2.0

package/dist/server/index.esm.js

@@ -0,0 +1,382 @@
+// src/server/card.ts
+function isCardRecord(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return false;
+  const vals = Object.values(v);
+  return vals.length > 0 && vals.every((x) => x instanceof Card);
+}
+
+class Card {
+  card = this.constructor.name;
+  constructor(props) {
+    if (props)
+      Object.assign(this, props);
+  }
+  generate() {
+    const data = {};
+    const children = {};
+    for (const key of Object.keys(this)) {
+      if (key === "card")
+        continue;
+      const value = this[key];
+      if (value instanceof Card) {
+        children[key] = value.generate();
+      } else if (Array.isArray(value) && value.length > 0 && value.every((v) => v instanceof Card)) {
+        children[key] = value.map((v) => v.generate());
+      } else if (isCardRecord(value)) {
+        children[key] = Object.fromEntries(Object.entries(value).map(([k, v]) => [
+          k,
+          v.generate()
+        ]));
+      } else {
+        data[key] = value;
+      }
+    }
+    return { ...children, card: this.card, data };
+  }
+  inputChildLoc() {
+    const acc = {};
+    const visit = (card) => {
+      const name = card.name;
+      if (card instanceof InputCard && typeof name === "string") {
+        acc[name] = card;
+      }
+      for (const key of Object.keys(card)) {
+        const v = card[key];
+        if (v instanceof Card)
+          visit(v);
+        else if (Array.isArray(v))
+          v.forEach((x) => x instanceof Card && visit(x));
+        else if (v && typeof v === "object")
+          Object.values(v).forEach((x) => x instanceof Card && visit(x));
+      }
+    };
+    visit(this);
+    return acc;
+  }
+  fill(data) {
+    const loc = this.inputChildLoc();
+    for (const [name, card] of Object.entries(loc)) {
+      if (name in data) {
+        card.value = data[name];
+      }
+    }
+    return this.generate();
+  }
+  createEvent(method, data = {}) {
+    const name = this.name;
+    if (typeof name !== "string") {
+      throw new Error("Card.createEvent requires a string `name`");
+    }
+    const self = this;
+    const io = self.useSocketioSupport || self.useCentrifugeSupport || self.useMittSupport;
+    if (!io) {
+      throw new Error("Card.createEvent requires an IO support flag enabled");
+    }
+    return { name: `pie${method}_${name}`, data };
+  }
+}
+
+class InputCard extends Card {
+  parse(raw) {
+    return raw;
+  }
+}
+// src/server/page.ts
+class AsyncPage {
+  fields;
+  isTyped;
+  ajaxPost = {};
+  ajaxGet = {};
+  publisher;
+  constructor(isTyped = false) {
+    this.isTyped = isTyped;
+  }
+  async getContent(_ctx = {}) {
+    if (this.fields)
+      return this.fields.fill({});
+    throw new Error("getContent not implemented and no `fields` set");
+  }
+  async process(_data) {
+    throw new Error("process not implemented");
+  }
+  registerAjax(pathname, fn, method = "POST") {
+    if (method === "POST")
+      this.ajaxPost[pathname] = fn;
+    else
+      this.ajaxGet[pathname] = fn;
+  }
+  setPublisher(p) {
+    this.publisher = p;
+  }
+  async emit(event, to) {
+    if (!this.publisher) {
+      throw new Error("no publisher configured (Web must call setPublisher)");
+    }
+    const events = Array.isArray(event) ? event : [event];
+    for (const ev of events)
+      await this.publisher(ev, to);
+  }
+}
+// src/server/web.ts
+import express from "express";
+import cookieParser from "cookie-parser";
+import jwt from "jsonwebtoken";
+import { createHash } from "node:crypto";
+
+// src/server/form.ts
+function form2dict(body) {
+  const out = {};
+  for (const [k, v] of Object.entries(body ?? {})) {
+    out[k] = Array.isArray(v) && v.length === 1 ? v[0] : v;
+  }
+  return out;
+}
+function aggregate(data, rule) {
+  if (rule !== "by_underscore")
+    return data;
+  const out = {};
+  for (const [k, v] of Object.entries(data)) {
+    const idx = k.indexOf("__");
+    if (idx === -1) {
+      out[k] = v;
+    } else {
+      const parent = k.slice(0, idx);
+      const child = k.slice(idx + 2);
+      const bucket = out[parent] ??= {};
+      bucket[child] = v;
+    }
+  }
+  return out;
+}
+
+// src/server/realtime.ts
+async function publishToCentrifuge(opts, fetchFn = fetch) {
+  const res = await fetchFn(`${opts.url.replace(/\/$/, "")}/api/publish`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": opts.apiKey
+    },
+    body: JSON.stringify({ channel: opts.channel, data: opts.data })
+  });
+  if (!res.ok) {
+    throw new Error(`centrifuge publish failed: ${res.status}`);
+  }
+}
+
+// src/server/web.ts
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+class Web {
+  pages;
+  opts;
+  constructor(pages, opts = {}) {
+    this.pages = pages;
+    const adminSubdomain = opts.adminSubdomain ?? "/";
+    if (!adminSubdomain.startsWith("/") || !adminSubdomain.endsWith("/")) {
+      throw new Error('adminSubdomain must start and end with "/"');
+    }
+    this.opts = { ...opts, adminSubdomain };
+    this.wirePublishers();
+  }
+  wirePublishers() {
+    if (!this.opts.useCentrifugeSupport || !this.opts.centrifugeUrl || !this.opts.centrifugeApiKey) {
+      return;
+    }
+    for (const entry of Object.values(this.pages)) {
+      if (typeof entry === "string")
+        continue;
+      entry.setPublisher(async (ev, to) => {
+        const channel = to ? `${ev.name}_${to}` : ev.name;
+        await publishToCentrifuge({
+          url: this.opts.centrifugeUrl,
+          apiKey: this.opts.centrifugeApiKey,
+          channel,
+          data: ev.data
+        });
+      });
+    }
+  }
+  resolvePage(pathname) {
+    let key = pathname.replace(/^\/+/, "");
+    let hops = 0;
+    while (hops++ < 10) {
+      const entry = this.pages[key];
+      if (entry === undefined)
+        return null;
+      if (typeof entry === "string") {
+        key = entry;
+        continue;
+      }
+      return entry;
+    }
+    return null;
+  }
+  contextFromRequest(req) {
+    const ctx = {};
+    for (const k of this.opts.cookieKeys ?? []) {
+      const c = req.cookies?.[k];
+      if (c !== undefined)
+        ctx[k] = c;
+    }
+    Object.assign(ctx, req.query);
+    return ctx;
+  }
+  collectAjax(kind) {
+    const map = {};
+    for (const entry of Object.values(this.pages)) {
+      if (typeof entry === "string")
+        continue;
+      Object.assign(map, entry[kind]);
+    }
+    return map;
+  }
+  getApp() {
+    const app = express();
+    app.use(express.urlencoded({ extended: true }));
+    app.use(express.json());
+    app.use(cookieParser());
+    if (this.opts.enableCors)
+      app.use(this.corsMiddleware());
+    const sub = this.opts.adminSubdomain;
+    const contentPrefix = `${sub}api/content/`;
+    const processPrefix = `${sub}api/process/`;
+    const ajaxPrefix = `${sub}api/ajax_content/`;
+    app.get(new RegExp("^" + escapeRegExp(contentPrefix)), async (req, res) => {
+      const pathname = decodeURIComponent(req.path.slice(contentPrefix.length));
+      const page = this.resolvePage(pathname);
+      if (!page) {
+        res.status(404).json({ error: "page not found" });
+        return;
+      }
+      try {
+        res.json(await page.getContent(this.contextFromRequest(req)));
+      } catch (e) {
+        res.status(500).json({ error: String(e) });
+      }
+    });
+    app.post(new RegExp("^" + escapeRegExp(processPrefix)), async (req, res) => {
+      const pathname = decodeURIComponent(req.path.slice(processPrefix.length));
+      const page = this.resolvePage(pathname);
+      if (!page) {
+        res.status(404).json({ error: "page not found" });
+        return;
+      }
+      const data = aggregate(form2dict(req.body), this.opts.aggregationRule);
+      try {
+        const result = await page.process(data);
+        if (typeof result !== "string") {
+          if (!res.headersSent)
+            res.status(204).end();
+          return;
+        }
+        let url = result;
+        if (url.startsWith("/")) {
+          url = sub + url.slice(1);
+          if (this.opts.disableServing && this.opts.servingUrl) {
+            url = this.opts.servingUrl + url;
+          }
+        }
+        res.redirect(303, url);
+      } catch (e) {
+        res.status(500).json({ error: String(e) });
+      }
+    });
+    const postAjax = this.collectAjax("ajaxPost");
+    const getAjax = this.collectAjax("ajaxGet");
+    app.post(new RegExp("^" + escapeRegExp(ajaxPrefix)), async (req, res) => {
+      const pathname = "/" + req.path.slice(ajaxPrefix.length);
+      const fn = postAjax[pathname];
+      if (!fn) {
+        res.status(404).json({ error: "ajax handler not found" });
+        return;
+      }
+      const data = aggregate(form2dict(req.body), this.opts.aggregationRule);
+      res.json(await fn(data));
+    });
+    app.get(new RegExp("^" + escapeRegExp(ajaxPrefix)), async (req, res) => {
+      const pathname = "/" + req.path.slice(ajaxPrefix.length);
+      const fn = getAjax[pathname];
+      if (!fn) {
+        res.status(404).json({ error: "ajax handler not found" });
+        return;
+      }
+      const data = aggregate({ ...req.query }, this.opts.aggregationRule);
+      res.json(await fn(data));
+    });
+    app.get(`${sub}api/support/:name`, (req, res) => {
+      const name = req.params.name;
+      const supported = name === "socketio" ? !!this.opts.useSocketioSupport : name === "centrifuge" ? !!this.opts.useCentrifugeSupport : false;
+      res.json(supported);
+    });
+    app.get("/api/centrifuge/gen_token", (req, res) => {
+      const secret = this.opts.centrifugeHmacSecret;
+      if (!secret) {
+        res.status(403).json({ error: "no centrifuge secret" });
+        return;
+      }
+      const cookies = {};
+      for (const k of this.opts.cookieKeys ?? []) {
+        const v = req.cookies?.[k];
+        if (typeof v === "string")
+          cookies[k] = v;
+      }
+      const subId = this.opts.centrifugeSubFn?.(cookies) ?? createHash("sha256").update(JSON.stringify(cookies)).digest("hex");
+      const now = Math.floor(Date.now() / 1000);
+      const token = jwt.sign({ sub: subId, iat: now, exp: now + 3600 }, secret, { algorithm: "HS256" });
+      res.json({ token });
+    });
+    return app;
+  }
+  corsMiddleware() {
+    const origins = this.opts.corsOrigins;
+    return (req, res, next) => {
+      const origin = req.headers.origin;
+      if (!origins || origin && origins.includes(origin)) {
+        res.setHeader("Access-Control-Allow-Origin", origin ?? "*");
+      }
+      res.setHeader("Access-Control-Allow-Credentials", "true");
+      res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+      res.setHeader("Vary", "Origin");
+      const reqHeaders = req.headers["access-control-request-headers"];
+      res.setHeader("Access-Control-Allow-Headers", (Array.isArray(reqHeaders) ? reqHeaders.join(",") : reqHeaders) || "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.sendStatus(204);
+        return;
+      }
+      next();
+    };
+  }
+}
+// src/server/cards/HiddenCard.ts
+class HiddenCard extends InputCard {
+}
+// src/server/cards/UnionCard.ts
+class UnionCard extends Card {
+}
+// src/server/cards/AjaxGroupCard.ts
+class AjaxGroupCard extends Card {
+}
+// src/server/cards/OneOfCard.ts
+class OneOfCard extends Card {
+}
+// src/server/cards/HTMLEmbedCard.ts
+class HTMLEmbedCard extends Card {
+}
+export {
+  publishToCentrifuge,
+  form2dict,
+  aggregate,
+  Web,
+  UnionCard,
+  OneOfCard,
+  InputCard,
+  HiddenCard,
+  HTMLEmbedCard,
+  Card,
+  AsyncPage,
+  AjaxGroupCard
+};