npm - @antelopejs/dms-frontend - Versions diffs - 0.0.1 - Mend

@antelopejs/dms-frontend 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

package/LICENSE +190 -0
package/README.md +131 -0
package/dist/commands/build.js +66 -0
package/dist/commands/clean.js +42 -0
package/dist/commands/dev.js +116 -0
package/dist/commands/prepare.js +60 -0
package/dist/commands/start.js +49 -0
package/dist/commands/verify-source.js +39 -0
package/dist/common.js +24 -0
package/dist/config.js +142 -0
package/dist/discovery.js +123 -0
package/dist/fs-sync.js +142 -0
package/dist/index.js +44 -0
package/dist/layer-watch.js +154 -0
package/dist/layers.js +120 -0
package/dist/manifest.js +109 -0
package/dist/materialize.js +249 -0
package/dist/ports.js +30 -0
package/dist/update-check.js +173 -0
package/dist/utils/cli-ui.js +178 -0
package/dist/verify-source-runner.js +228 -0
package/dist/workspace-setup.js +109 -0
package/dist/workspace.js +76 -0
package/package.json +97 -0
package/templates/vue/DmsDynamicPage.vue +89 -0
package/templates/vue/app-config-stub.mjs +1 -0
package/templates/vue/app-runtime.ts +240 -0
package/templates/vue/compress-assets.mjs +48 -0
package/templates/vue/email-locales.ts +32 -0
package/templates/vue/email-renderer.ts +159 -0
package/templates/vue/email-runtime.ts +23 -0
package/templates/vue/frontend-module.ts +1418 -0
package/templates/vue/globals.d.ts +1 -0
package/templates/vue/index.html +24 -0
package/templates/vue/main.ts +33 -0
package/templates/vue/npmrc +2 -0
package/templates/vue/package.json +35 -0
package/templates/vue/pnpm-workspace.yaml +4 -0
package/templates/vue/server/auth/backend.mjs +83 -0
package/templates/vue/server/auth/client-ip.mjs +52 -0
package/templates/vue/server/auth/oauth.mjs +213 -0
package/templates/vue/server/auth/routes.mjs +254 -0
package/templates/vue/server/auth/session.mjs +180 -0
package/templates/vue/server/client-manifest.mjs +116 -0
package/templates/vue/server/email.mjs +36 -0
package/templates/vue/server/inertia.mjs +79 -0
package/templates/vue/server/render-token.mjs +81 -0
package/templates/vue/server/tester.mjs +228 -0
package/templates/vue/server.mjs +526 -0
package/templates/vue/ssr-renderer.ts +146 -0
package/templates/vue/tsconfig.json +31 -0
package/templates/vue/typecheck-loader.mjs +13 -0
package/templates/vue/vite.config.ts +161 -0
package/templates/vue/vite.email.config.ts +77 -0

package/templates/vue/globals.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ declare const defineAppConfig: typeof import("./frontend-module").defineAppConfig;

package/templates/vue/index.html ADDED Viewed

@@ -0,0 +1,24 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" href="data:," />
+    <script>
+      const preference = localStorage.getItem("dms-color-mode") || "system";
+      const mode =
+        preference === "system"
+          ? matchMedia("(prefers-color-scheme: dark)").matches
+            ? "dark"
+            : "light"
+          : preference;
+      document.documentElement.classList.add(mode);
+    </script>
+    <title>Antelope DMS</title>
+  </head>
+  <body>
+    <div class="isolate">__DMS_APP__</div>
+    <div id="dms-overlays" class="isolate"></div>
+    <script type="module" src="/main.ts" fetchpriority="low"></script>
+  </body>
+</html>

package/templates/vue/main.ts ADDED Viewed

@@ -0,0 +1,33 @@
+import "./dms-main.css";
+import { createInertiaApp } from "@inertiajs/vue3";
+import { createHead } from "@unhead/vue/client";
+import { createApp, createSSRApp, h } from "vue";
+import { configureDmsApp, resolveDmsInertiaPage } from "./app-runtime";
+import { setupFrontendModules } from "./frontend-module";
+import { frontendModules } from "./frontend-modules.generated";
+function markDmsReady(): void {
+  document.documentElement.dataset.dmsReady = "true";
+}
+await setupFrontendModules(frontendModules);
+createInertiaApp({
+  resolve: resolveDmsInertiaPage,
+  async setup({ App, el, props, plugin }) {
+    const root = { render: () => h(App, props) };
+    const app = el.hasAttribute("data-server-rendered")
+      ? createSSRApp(root)
+      : createApp(root);
+    const configured = await configureDmsApp({
+      app,
+      head: createHead(),
+      initialPageProps: props.initialPage.props,
+      initialPageUrl: props.initialPage.url,
+      inertiaPlugin: plugin,
+    });
+    app.mount(el);
+    markDmsReady();
+    await configured.mounted();
+  },
+});

package/templates/vue/npmrc ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ shamefully-hoist=true
2	+ strict-peer-dependencies=false

package/templates/vue/package.json ADDED Viewed

@@ -0,0 +1,35 @@
+{
+  "name": "dms-frontend-workspace",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build && node compress-assets.mjs && vite build --ssr ssr-renderer.ts --outDir dist/ssr && vite build --config vite.email.config.ts",
+    "typecheck": "node --import ./typecheck-loader.mjs ./node_modules/vue-tsc/bin/vue-tsc.js --noEmit",
+    "start": "node server.mjs"
+  },
+  "dependencies": {
+    "@inertiajs/vue3": "^3.7.0",
+    "@nuxt/ui": "4.10.0",
+    "@tailwindcss/typography": "^0.5.19",
+    "@unhead/vue": "^2.0.14",
+    "@vitejs/plugin-vue": "^6.0.0",
+    "@vue/server-renderer": "^3.5.0",
+    "@vueuse/core": "^13.0.0",
+    "defu": "^6.1.4",
+    "ofetch": "^1.4.1",
+    "reka-ui": "^2.6.0",
+    "tailwindcss": "^4.0.0",
+    "ufo": "^1.6.1",
+    "unplugin-auto-import": "^20.2.0",
+    "unplugin-vue-components": "^29.0.0",
+    "vite": "^7.0.0",
+    "vue": "^3.5.0",
+    "vue-i18n": "^11.1.12"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.2",
+    "vue-tsc": "3.1.1"
+  },
+  "packageManager": "pnpm@10.6.5"
+}

package/templates/vue/pnpm-workspace.yaml ADDED Viewed

@@ -0,0 +1,4 @@
+packages:
+  - .
+  - frontend-modules/*
+ignore-workspace-root-check: true

package/templates/vue/server/auth/backend.mjs ADDED Viewed

@@ -0,0 +1,83 @@
+import { clientIp } from "./client-ip.mjs";
+const FORWARDED_HEADERS = [
+  "user-agent",
+  "x-content-language",
+  "x-realtime-session",
+];
+const BODY_LIMIT = 64 * 1024;
+export class UpstreamError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+const PUBLIC_AUTH_MESSAGE = /^error\.[a-z0-9_.-]{1,100}$/;
+export function publicBackendMessage(data) {
+  const message = typeof data === "string" ? data : data?.message;
+  return typeof message === "string" && PUBLIC_AUTH_MESSAGE.test(message)
+    ? message
+    : undefined;
+}
+export async function backend(path, request, options = {}) {
+  const headers = Object.fromEntries(
+    FORWARDED_HEADERS.flatMap((name) =>
+      request.headers[name] ? [[name, request.headers[name]]] : [],
+    ),
+  );
+  headers["x-forwarded-for"] = clientIp(request);
+  if (options.token) headers.authorization = `Bearer ${options.token}`;
+  if (options.relay)
+    headers["x-dms-oauth-relay"] = process.env.DMS_OAUTH_RELAY_SECRET ?? "";
+  if (options.body !== undefined) headers["content-type"] = "application/json";
+  const response = await fetch(new URL(path, process.env.DMS_BACKEND_URL), {
+    method: options.method ?? "GET",
+    headers,
+    body: options.body === undefined ? undefined : JSON.stringify(options.body),
+  });
+  const text = await response.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = response.ok ? {} : text;
+  }
+  if (!response.ok) {
+    const message = publicBackendMessage(data) ?? "DMS backend request failed";
+    throw new UpstreamError(response.status, message);
+  }
+  return data;
+}
+export async function body(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    size += chunk.length;
+    if (size > BODY_LIMIT)
+      throw new RequestBodyError(413, "Request body too large");
+    chunks.push(chunk);
+  }
+  if (!chunks.length) return {};
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new RequestBodyError(400, "Invalid request body");
+  }
+}
+export class RequestBodyError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+export function json(response, status, value) {
+  response.writeHead(status, { "content-type": "application/json" });
+  response.end(JSON.stringify(value));
+}

package/templates/vue/server/auth/client-ip.mjs ADDED Viewed

@@ -0,0 +1,52 @@
+function trustedHops() {
+  const value = Number.parseInt(process.env.DMS_TRUSTED_PROXY_HOPS ?? "0", 10);
+  return Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+export function requestScheme(request) {
+  if (trustedHops()) {
+    const forwarded = String(request.headers["x-forwarded-proto"] ?? "")
+      .split(",")
+      .map((value) => value.trim().toLowerCase())
+      .filter((value) => value === "http" || value === "https")
+      .at(-1);
+    if (forwarded) return forwarded;
+  }
+  return request.socket?.encrypted ? "https" : "http";
+}
+function requestHost(request) {
+  if (!trustedHops()) return request.headers.host;
+  return (
+    String(request.headers["x-forwarded-host"] ?? "")
+      .split(",")
+      .map((value) => value.trim())
+      .filter(Boolean)
+      .at(-1) || request.headers.host
+  );
+}
+export function isSameOrigin(request) {
+  const origin = request.headers.origin;
+  if (!origin) return false;
+  try {
+    return (
+      new URL(origin).origin ===
+      new URL(`${requestScheme(request)}://${requestHost(request)}`).origin
+    );
+  } catch {
+    return false;
+  }
+}
+export function clientIp(request) {
+  const socketIp = request.socket?.remoteAddress || "unknown";
+  const hops = trustedHops();
+  if (!hops) return socketIp;
+  const forwarded = String(request.headers["x-forwarded-for"] ?? "")
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+  const chain = [...forwarded, socketIp];
+  return chain[Math.max(0, chain.length - hops - 1)] ?? socketIp;
+}

package/templates/vue/server/auth/oauth.mjs ADDED Viewed

@@ -0,0 +1,213 @@
+import { timingSafeEqual } from "node:crypto";
+import { backend, json } from "./backend.mjs";
+import { clientIp } from "./client-ip.mjs";
+import {
+  clearSealedCookie,
+  persistAccountSession,
+  readSealedCookie,
+  writeSealedCookie,
+} from "./session.mjs";
+const FLOW = "dms_oauth_flow";
+const HANDOFF = "dms_oauth_handoff";
+const COMPLETE = "/auth/oauth/complete";
+const FLOW_LIFETIME_MS = 10 * 60 * 1000;
+const RATE_WINDOW_MS = 60 * 1000;
+const RATE_LIMIT = 10;
+const MAX_RATE_LIMIT_CLIENTS = 10_000;
+const MAX_CALLBACK_PARAMETER_LENGTH = 2048;
+const attempts = new Map();
+export function resolveOAuthClientKey(request) {
+  return clientIp(request);
+}
+function sweepAttempts(now) {
+  for (const [key, window] of attempts) {
+    if (now - window.startedAt >= RATE_WINDOW_MS) attempts.delete(key);
+  }
+  while (attempts.size >= MAX_RATE_LIMIT_CLIENTS)
+    attempts.delete(attempts.keys().next().value);
+}
+export function hitOAuthRateLimitKey(key, now = Date.now()) {
+  sweepAttempts(now);
+  const window = attempts.get(key);
+  if (!window || now - window.startedAt >= RATE_WINDOW_MS) {
+    attempts.set(key, { count: 1, startedAt: now });
+    return true;
+  }
+  window.count += 1;
+  return window.count <= RATE_LIMIT;
+}
+function rateLimited(request, scope) {
+  const now = Date.now();
+  return !hitOAuthRateLimitKey(
+    `${scope}:${resolveOAuthClientKey(request)}`,
+    now,
+  );
+}
+export function isValidOAuthProvider(provider) {
+  return typeof provider === "string" && /^[a-z0-9-]{1,32}$/.test(provider);
+}
+function safePath(value) {
+  if (
+    typeof value !== "string" ||
+    !value.startsWith("/") ||
+    value.startsWith("//") ||
+    value.includes("\\")
+  )
+    return "";
+  try {
+    const decoded = decodeURIComponent(value);
+    return decoded.startsWith("//") || decoded.includes("\\") ? "" : value;
+  } catch {
+    return "";
+  }
+}
+function redirect(response, location) {
+  response.writeHead(302, { location });
+  response.end();
+}
+function errorRedirect(response, key) {
+  redirect(response, `/auth?oauth_error=${encodeURIComponent(key)}`);
+}
+export async function oauthStart(request, response, provider, url) {
+  if (
+    !isValidOAuthProvider(provider) ||
+    request.headers["sec-fetch-site"] === "cross-site" ||
+    rateLimited(request, "start")
+  )
+    return errorRedirect(response, "error.oauth.failed");
+  try {
+    const result = await backend(
+      `/api/auth/oauth/${provider}/authorize-url`,
+      request,
+      { relay: true },
+    );
+    writeSealedCookie(
+      response,
+      FLOW,
+      {
+        state: result.state,
+        expiresAt: Date.now() + FLOW_LIFETIME_MS,
+        redirect: safePath(url.searchParams.get("redirect")),
+        language: url.searchParams.get("language") ?? "",
+        invite: url.searchParams.get("invite") ?? "",
+      },
+      FLOW_LIFETIME_MS / 1000,
+    );
+    redirect(response, result.authorizeUrl);
+  } catch {
+    errorRedirect(response, "error.oauth.failed");
+  }
+}
+function sameState(left, right) {
+  if (typeof left !== "string" || typeof right !== "string") return false;
+  const a = Buffer.from(left);
+  const b = Buffer.from(right);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function validCallback(flow, url) {
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  return !(
+    !flow ||
+    flow.expiresAt < Date.now() ||
+    typeof code !== "string" ||
+    code.length > MAX_CALLBACK_PARAMETER_LENGTH ||
+    typeof state !== "string" ||
+    state.length > MAX_CALLBACK_PARAMETER_LENGTH ||
+    !sameState(state, flow.state)
+  );
+}
+function storeOAuthResult(request, response, provider, result) {
+  if (result.requires_2fa)
+    writeSealedCookie(
+      response,
+      HANDOFF,
+      { kind: "2fa", token: result.two_factor_token, methods: result.methods },
+      300,
+    );
+  else if (result.requires_tenant_assignment)
+    writeSealedCookie(
+      response,
+      HANDOFF,
+      { kind: "no-workspace", token: result.tenant_assignment_token, provider },
+      300,
+    );
+  else persistAccountSession(request, response, sessionFrom(result));
+}
+async function completeOAuth(request, response, provider, url, flow) {
+  try {
+    const result = await backend(
+      `/api/auth/oauth/${provider}/callback`,
+      request,
+      {
+        method: "POST",
+        relay: true,
+        body: {
+          code: url.searchParams.get("code"),
+          state: url.searchParams.get("state"),
+          state_cookie: flow.state,
+          language: flow.language || undefined,
+          invite: flow.invite || undefined,
+        },
+      },
+    );
+    storeOAuthResult(request, response, provider, result);
+    redirect(
+      response,
+      flow.redirect &&
+        !result.requires_2fa &&
+        !result.requires_tenant_assignment
+        ? `${COMPLETE}?redirect=${encodeURIComponent(flow.redirect)}`
+        : COMPLETE,
+    );
+  } catch {
+    errorRedirect(response, "error.oauth.failed");
+  }
+}
+export async function oauthCallback(request, response, provider, url) {
+  if (!isValidOAuthProvider(provider) || rateLimited(request, "callback"))
+    return errorRedirect(response, "error.oauth.failed");
+  const flow = readSealedCookie(request, FLOW);
+  clearSealedCookie(response, FLOW);
+  if (url.searchParams.has("error"))
+    return errorRedirect(response, "error.oauth.cancelled");
+  if (!validCallback(flow, url))
+    return errorRedirect(response, "error.oauth.invalid_state");
+  return completeOAuth(request, response, provider, url, flow);
+}
+export function oauthHandoff(request, response) {
+  const handoff = readSealedCookie(request, HANDOFF) ?? { kind: "none" };
+  clearSealedCookie(response, HANDOFF);
+  json(response, 200, handoff);
+}
+export function sessionFrom(result) {
+  const payload = JSON.parse(
+    Buffer.from(
+      result.access_token.split(".")[1] ?? "",
+      "base64url",
+    ).toString() || "{}",
+  );
+  return {
+    user: result.user,
+    accessToken: result.access_token,
+    refreshToken: result.refresh_token,
+    activeTenantId: payload.tenantId ?? "default",
+  };
+}