@intranefr/superbackend 1.4.3

package/sdk/error-tracking/browser/src/core.js

@@ -0,0 +1,270 @@
+export function createErrorTrackingClient(options) {
+  const state = {
+    initialized: false,
+    config: {
+      endpoint: '/api/log/error',
+      headers: {},
+      getAuthHeader: null,
+      maxErrorsPerSession: 50,
+      debounceMs: 1000,
+      sampleRatePercent: 100,
+      ...(options || {}),
+    },
+    errorCount: 0,
+    lastErrorTime: 0,
+    lastErrorFingerprint: '',
+    originalFetch: null,
+  };
+
+  function randomInt0_99() {
+    return Math.floor(Math.random() * 100);
+  }
+
+  function shouldSample() {
+    const pct = Number(state.config.sampleRatePercent);
+    if (!Number.isFinite(pct)) return true;
+    if (pct >= 100) return true;
+    if (pct <= 0) return false;
+    return randomInt0_99() < pct;
+  }
+
+  function computeFingerprint(errorName, message, url) {
+    return `${errorName || ''}|${String(message || '').slice(0, 120)}|${url || ''}`;
+  }
+
+  function shouldReport(fingerprint) {
+    if (!shouldSample()) return false;
+
+    const now = Date.now();
+
+    if (state.errorCount >= state.config.maxErrorsPerSession) {
+      return false;
+    }
+
+    if (fingerprint === state.lastErrorFingerprint && (now - state.lastErrorTime) < state.config.debounceMs) {
+      return false;
+    }
+
+    state.lastErrorFingerprint = fingerprint;
+    state.lastErrorTime = now;
+    state.errorCount += 1;
+
+    return true;
+  }
+
+  function getRuntime() {
+    let appVersion = '';
+    try {
+      const meta = document.querySelector('meta[name="app-version"]');
+      appVersion = meta && meta.content ? meta.content : '';
+    } catch (e) {
+      appVersion = '';
+    }
+
+    return {
+      url: window.location.href,
+      referrer: document.referrer || '',
+      viewport: `${window.innerWidth}x${window.innerHeight}`,
+      locale: navigator.language || '',
+      appVersion,
+    };
+  }
+
+  function buildHeaders() {
+    const headers = { ...(state.config.headers || {}) };
+
+    const getter = state.config.getAuthHeader;
+    if (typeof getter === 'function') {
+      try {
+        const auth = getter();
+        if (auth) headers.authorization = auth;
+      } catch (e) {}
+    }
+
+    return headers;
+  }
+
+  function sendError(payload) {
+    try {
+      const endpoint = state.config.endpoint || '/api/log/error';
+      const headers = buildHeaders();
+
+      if (navigator.sendBeacon) {
+        try {
+          const blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
+          const ok = navigator.sendBeacon(endpoint, blob);
+          if (ok) return;
+        } catch (e) {}
+      }
+
+      const xhr = new XMLHttpRequest();
+      xhr.open('POST', endpoint, true);
+      xhr.setRequestHeader('Content-Type', 'application/json');
+      Object.keys(headers || {}).forEach((k) => {
+        if (headers[k] != null) xhr.setRequestHeader(k, String(headers[k]));
+      });
+      xhr.send(JSON.stringify(payload));
+    } catch (e) {}
+  }
+
+  function normalizeErrorReason(reason) {
+    if (reason instanceof Error) {
+      return {
+        errorName: reason.name || 'UnhandledRejection',
+        message: reason.message,
+        stack: reason.stack || '',
+      };
+    }
+
+    if (typeof reason === 'string') {
+      return { errorName: 'UnhandledRejection', message: reason, stack: '' };
+    }
+
+    try {
+      return { errorName: 'UnhandledRejection', message: JSON.stringify(reason), stack: '' };
+    } catch (e) {
+      return { errorName: 'UnhandledRejection', message: String(reason), stack: '' };
+    }
+  }
+
+  function handleWindowError(message, source, lineno, colno, error) {
+    const errorName = (error && error.name) || 'Error';
+    const errorMessage = (error && error.message) || message || 'Unknown error';
+    const stack = (error && error.stack) || '';
+
+    const fingerprint = computeFingerprint(errorName, errorMessage, source || window.location.href);
+    if (!shouldReport(fingerprint)) return;
+
+    sendError({
+      severity: 'error',
+      errorName,
+      message: errorMessage,
+      stack,
+      url: source || window.location.href,
+      runtime: getRuntime(),
+      extra: { lineno, colno },
+    });
+  }
+
+  function handleUnhandledRejection(event) {
+    const norm = normalizeErrorReason(event && event.reason);
+
+    const fingerprint = computeFingerprint(norm.errorName, norm.message, window.location.href);
+    if (!shouldReport(fingerprint)) return;
+
+    sendError({
+      severity: 'error',
+      errorName: norm.errorName,
+      message: norm.message,
+      stack: norm.stack,
+      url: window.location.href,
+      runtime: getRuntime(),
+    });
+  }
+
+  function wrapFetch() {
+    if (state.originalFetch || typeof window.fetch !== 'function') return;
+
+    state.originalFetch = window.fetch;
+    window.fetch = function (input, init) {
+      return state.originalFetch.apply(this, arguments).then((response) => {
+        try {
+          if (response && response.status >= 500) {
+            const url = typeof input === 'string' ? input : (input && input.url) || '';
+            const method = (init && init.method) || 'GET';
+            const fingerprint = computeFingerprint('FetchError', `${response.status} ${url}`, url);
+            if (shouldReport(fingerprint)) {
+              sendError({
+                severity: 'warn',
+                errorName: 'FetchError',
+                message: `HTTP ${response.status} on ${method} ${url}`,
+                request: { method, path: url, statusCode: response.status },
+                runtime: getRuntime(),
+              });
+            }
+          }
+        } catch (e) {}
+        return response;
+      }).catch((err) => {
+        try {
+          const url = typeof input === 'string' ? input : (input && input.url) || '';
+          const method = (init && init.method) || 'GET';
+          const message = (err && err.message) || String(err);
+          const stack = (err && err.stack) || '';
+          const fingerprint = computeFingerprint('FetchError', message, url);
+          if (shouldReport(fingerprint)) {
+            sendError({
+              severity: 'error',
+              errorName: 'FetchError',
+              message,
+              stack,
+              request: { method, path: url },
+              runtime: getRuntime(),
+            });
+          }
+        } catch (e) {}
+        throw err;
+      });
+    };
+  }
+
+  function init(initOptions) {
+    if (state.initialized) return;
+    if (initOptions) config(initOptions);
+
+    window.addEventListener('error', (event) => {
+      handleWindowError(event && event.message, event && event.filename, event && event.lineno, event && event.colno, event && event.error);
+    });
+
+    window.addEventListener('unhandledrejection', handleUnhandledRejection);
+
+    wrapFetch();
+
+    state.initialized = true;
+  }
+
+  function config(next) {
+    if (!next || typeof next !== 'object') return;
+
+    state.config = {
+      ...state.config,
+      ...next,
+      headers: {
+        ...(state.config.headers || {}),
+        ...(next.headers || {}),
+      },
+    };
+  }
+
+  function report(error, extra) {
+    const errorName = (error && error.name) || 'CustomError';
+    const errorMessage = (error && error.message) || String(error);
+    const stack = (error && error.stack) || '';
+
+    const fingerprint = computeFingerprint(errorName, errorMessage, window.location.href);
+    if (!shouldReport(fingerprint)) return;
+
+    sendError({
+      severity: 'error',
+      errorName,
+      message: errorMessage,
+      stack,
+      url: window.location.href,
+      runtime: getRuntime(),
+      extra,
+    });
+  }
+
+  function teardown() {
+    if (!state.initialized) return;
+
+    try {
+      window.fetch = state.originalFetch || window.fetch;
+      state.originalFetch = null;
+    } catch (e) {}
+
+    state.initialized = false;
+  }
+
+  return { init, config, report, teardown };
+}

package/sdk/error-tracking/browser/src/embed.js

@@ -0,0 +1,18 @@
+import { createErrorTrackingClient } from './core.js';
+
+function attachToSaasbackendGlobal() {
+  const root = (typeof window !== 'undefined' ? window : undefined);
+  if (!root) return;
+
+  root.saasbackend = root.saasbackend || {};
+
+  if (!root.saasbackend.errorTracking) {
+    root.saasbackend.errorTracking = createErrorTrackingClient();
+  }
+
+  if (root.saasbackend.errorTracking && typeof root.saasbackend.errorTracking.init === 'function') {
+    root.saasbackend.errorTracking.init();
+  }
+}
+
+attachToSaasbackendGlobal();

package/sdk/error-tracking/browser/src/index.js

@@ -0,0 +1 @@
+export { createErrorTrackingClient } from './core.js';

package/server.js

@@ -0,0 +1,5 @@
+require('dotenv').config();
+const { server } = require('./index');
+
+// Start the standalone server
+server();

package/src/admin/endpointRegistry.js

@@ -0,0 +1,300 @@
+const endpointRegistry = [
+  {
+    id: "auth",
+    title: "Authentication",
+    endpoints: [
+      {
+        id: "register",
+        method: "POST",
+        path: "/api/auth/register",
+        auth: "none",
+        bodyExample: { email: "user@example.com", password: "password" },
+      },
+      {
+        id: "login",
+        method: "POST",
+        path: "/api/auth/login",
+        auth: "none",
+        bodyExample: { email: "user@example.com", password: "password" },
+      },
+      {
+        id: "refresh",
+        method: "POST",
+        path: "/api/auth/refresh-token",
+        auth: "none",
+        bodyExample: { refreshToken: "<refresh_token>" },
+      },
+      {
+        id: "me",
+        method: "GET",
+        path: "/api/auth/me",
+        auth: "jwt",
+      },
+    ],
+  },
+  {
+    id: "admin-llm",
+    title: "AI & LLM Services",
+    endpoints: [
+      {
+        id: "llm-config-get",
+        method: "GET",
+        path: "/api/admin/llm/config",
+        auth: "basic",
+      },
+      {
+        id: "llm-config-save",
+        method: "POST",
+        path: "/api/admin/llm/config",
+        auth: "basic",
+        bodyExample: { provider: "openai", apiKey: "sk-...", model: "gpt-4" },
+      },
+      {
+        id: "llm-prompt-test",
+        method: "POST",
+        path: "/api/admin/llm/prompts/:key/test",
+        auth: "basic",
+        bodyExample: { inputs: { topic: "SaaS" } },
+      },
+      {
+        id: "llm-audit",
+        method: "GET",
+        path: "/api/admin/llm/audit",
+        auth: "basic",
+      },
+      {
+        id: "llm-costs",
+        method: "GET",
+        path: "/api/admin/llm/costs",
+        auth: "basic",
+      },
+    ],
+  },
+  {
+    id: "ejs-virtual",
+    title: "EJS Virtual Codebase",
+    endpoints: [
+      {
+        id: "ejs-files-list",
+        method: "GET",
+        path: "/api/admin/ejs-virtual/files",
+        auth: "basic",
+      },
+      {
+        id: "ejs-file-get",
+        method: "GET",
+        path: "/api/admin/ejs-virtual/file?path=index.ejs",
+        auth: "basic",
+      },
+      {
+        id: "ejs-file-save",
+        method: "PUT",
+        path: "/api/admin/ejs-virtual/file",
+        auth: "basic",
+        bodyExample: { path: "index.ejs", content: "<h1>Hello</h1>" },
+      },
+      {
+        id: "ejs-vibe",
+        method: "POST",
+        path: "/api/admin/ejs-virtual/vibe",
+        auth: "basic",
+        bodyExample: { prompt: "Make it more professional" },
+      },
+      {
+        id: "ejs-cache-clear",
+        method: "POST",
+        path: "/api/admin/ejs-virtual/cache/clear",
+        auth: "basic",
+      },
+    ],
+  },
+  {
+    id: "seo-config",
+    title: "SEO & OpenGraph",
+    endpoints: [
+      {
+        id: "seo-get",
+        method: "GET",
+        path: "/api/admin/seo-config",
+        auth: "basic",
+      },
+      {
+        id: "seo-update",
+        method: "PUT",
+        path: "/api/admin/seo-config",
+        auth: "basic",
+        bodyExample: { defaultTitle: "My SaaS", defaultDescription: "Best SaaS" },
+      },
+      {
+        id: "seo-ai-views",
+        method: "GET",
+        path: "/api/admin/seo-config/ai/views",
+        auth: "basic",
+      },
+      {
+        id: "seo-ai-generate",
+        method: "POST",
+        path: "/api/admin/seo-config/ai/generate-entry",
+        auth: "basic",
+        bodyExample: { path: "/home" },
+      },
+      {
+        id: "seo-og-svg-update",
+        method: "PUT",
+        path: "/api/admin/seo-config/og/svg",
+        auth: "basic",
+        bodyExample: { svg: "<svg>...</svg>" },
+      },
+      {
+        id: "seo-og-generate-png",
+        method: "POST",
+        path: "/api/admin/seo-config/og/generate-png",
+        auth: "basic",
+      },
+    ],
+  },
+  {
+    id: "migration",
+    title: "System Migration",
+    endpoints: [
+      {
+        id: "migration-envs",
+        method: "GET",
+        path: "/api/admin/migration/environments",
+        auth: "basic",
+      },
+      {
+        id: "migration-models",
+        method: "GET",
+        path: "/api/admin/migration/models",
+        auth: "basic",
+      },
+      {
+        id: "migration-test",
+        method: "POST",
+        path: "/api/admin/migration/test-connection",
+        auth: "basic",
+        bodyExample: { targetUrl: "https://peer.example.com", apiKey: "..." },
+      },
+      {
+        id: "migration-run",
+        method: "POST",
+        path: "/api/admin/migration/run",
+        auth: "basic",
+        bodyExample: { envKey: "production", models: ["User"] },
+      },
+    ],
+  },
+  {
+    id: "billing",
+    title: "Billing & Stripe",
+    endpoints: [
+      {
+        id: "stripe-status",
+        method: "GET",
+        path: "/api/admin/stripe/status",
+        auth: "basic",
+      },
+      {
+        id: "stripe-catalog",
+        method: "GET",
+        path: "/api/admin/stripe/catalog",
+        auth: "basic",
+      },
+      {
+        id: "stripe-products",
+        method: "GET",
+        path: "/api/admin/stripe/products",
+        auth: "basic",
+      },
+      {
+        id: "billing-checkout",
+        method: "POST",
+        path: "/api/billing/create-checkout-session",
+        auth: "jwt",
+        bodyExample: { priceId: "price_xxx" },
+      },
+    ],
+  },
+  {
+    id: "admin-users",
+    title: "User Management (Admin)",
+    endpoints: [
+      {
+        id: "admin-users-stats",
+        method: "GET",
+        path: "/api/admin/users/stats",
+        auth: "basic",
+      },
+      {
+        id: "admin-users-list",
+        method: "GET",
+        path: "/api/admin/users",
+        auth: "basic",
+      },
+      {
+        id: "admin-users-get",
+        method: "GET",
+        path: "/api/admin/users/:id",
+        auth: "basic",
+      },
+    ],
+  },
+  {
+    id: "global-settings",
+    title: "Global Settings",
+    endpoints: [
+      {
+        id: "global-settings-list",
+        method: "GET",
+        path: "/api/admin/settings",
+        auth: "basic",
+      },
+      {
+        id: "global-setting-get",
+        method: "GET",
+        path: "/api/admin/settings/:key",
+        auth: "basic",
+      },
+      {
+        id: "global-setting-update",
+        method: "PUT",
+        path: "/api/admin/settings/:key",
+        auth: "basic",
+        bodyExample: { value: "new-value" },
+      },
+    ],
+  },
+  {
+    id: "errors-audit",
+    title: "Errors & Audit",
+    endpoints: [
+      {
+        id: "errors-list",
+        method: "GET",
+        path: "/api/admin/errors",
+        auth: "basic",
+      },
+      {
+        id: "errors-stats",
+        method: "GET",
+        path: "/api/admin/errors/stats",
+        auth: "basic",
+      },
+      {
+        id: "audit-list",
+        method: "GET",
+        path: "/api/admin/audit",
+        auth: "basic",
+      },
+      {
+        id: "audit-actions",
+        method: "GET",
+        path: "/api/admin/audit/actions",
+        auth: "basic",
+      },
+    ],
+  },
+];
+
+module.exports = endpointRegistry;