@djangocfg/monitor 2.1.322 → 2.1.327

package/src/_api/generated/_shared/logger.ts

@@ -0,0 +1,123 @@
+// AUTO-GENERATED by django_generator / ts_extras.wrapper
+// API logger built on consola. Optional dependency — install if you enable logging:
+//   npm install consola
+// DO NOT EDIT — re-run `make gen`.
+
+import { type ConsolaInstance, createConsola } from "consola";
+
+export interface RequestLog {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  body?: any;
+  timestamp: number;
+}
+
+export interface ResponseLog {
+  status: number;
+  statusText: string;
+  data?: any;
+  duration: number;
+  timestamp: number;
+}
+
+export interface ErrorLog {
+  message: string;
+  statusCode?: number;
+  fieldErrors?: Record<string, string[]>;
+  duration: number;
+  timestamp: number;
+}
+
+export interface LoggerConfig {
+  enabled: boolean;
+  logRequests: boolean;
+  logResponses: boolean;
+  logErrors: boolean;
+  logBodies: boolean;
+  logHeaders: boolean;
+  consola?: ConsolaInstance;
+}
+
+const DEFAULT_CONFIG: LoggerConfig = {
+  enabled: typeof process !== "undefined" && process.env?.NODE_ENV !== "production",
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false,
+};
+
+const SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token",
+];
+
+export class APILogger {
+  private config: LoggerConfig;
+  private consola: ConsolaInstance;
+
+  constructor(config: Partial<LoggerConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.consola = config.consola || createConsola({
+      level: this.config.enabled ? 4 : 0,
+    });
+  }
+
+  enable(): void { this.config.enabled = true; }
+  disable(): void { this.config.enabled = false; }
+  setConfig(config: Partial<LoggerConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  private filterHeaders(headers?: Record<string, string>): Record<string, string> {
+    if (!headers) return {};
+    const filtered: Record<string, string> = {};
+    Object.keys(headers).forEach((key) => {
+      filtered[key] = SENSITIVE_HEADERS.includes(key.toLowerCase()) ? "***" : (headers[key] || "");
+    });
+    return filtered;
+  }
+
+  logRequest(request: RequestLog): void {
+    if (!this.config.enabled || !this.config.logRequests) return;
+    const { method, url, headers, body } = request;
+    this.consola.start(`${method} ${url}`);
+    if (this.config.logHeaders && headers) this.consola.debug("Headers:", this.filterHeaders(headers));
+    if (this.config.logBodies && body) this.consola.debug("Body:", body);
+  }
+
+  logResponse(request: RequestLog, response: ResponseLog): void {
+    if (!this.config.enabled || !this.config.logResponses) return;
+    const { method, url } = request;
+    const { status, statusText, data, duration } = response;
+    this.consola.success(`${method} ${url} ${status} ${statusText} (${duration}ms)`);
+    if (this.config.logBodies && data) this.consola.debug("Response:", data);
+  }
+
+  logError(request: RequestLog, error: ErrorLog): void {
+    if (!this.config.enabled || !this.config.logErrors) return;
+    const { method, url } = request;
+    const { message, statusCode, fieldErrors, duration } = error;
+    this.consola.error(`${method} ${url} ${statusCode || "Network"} Error (${duration}ms)`);
+    this.consola.error("Message:", message);
+    if (fieldErrors && Object.keys(fieldErrors).length > 0) {
+      this.consola.error("Field Errors:");
+      Object.entries(fieldErrors).forEach(([field, errors]) => {
+        errors.forEach((err) => this.consola.error(`  • ${field}: ${err}`));
+      });
+    }
+  }
+
+  info(message: string, ...args: any[]): void { if (this.config.enabled) this.consola.info(message, ...args); }
+  warn(message: string, ...args: any[]): void { if (this.config.enabled) this.consola.warn(message, ...args); }
+  error(message: string, ...args: any[]): void { if (this.config.enabled) this.consola.error(message, ...args); }
+  debug(message: string, ...args: any[]): void { if (this.config.enabled) this.consola.debug(message, ...args); }
+  success(message: string, ...args: any[]): void { if (this.config.enabled) this.consola.success(message, ...args); }
+  withTag(tag: string): ConsolaInstance { return this.consola.withTag(tag); }
+}
+
+export const defaultLogger = new APILogger();

package/src/_api/generated/_shared/storage.ts

@@ -0,0 +1,83 @@
+// AUTO-GENERATED by django_generator / ts_extras.wrapper
+// Storage adapters for token persistence.
+// DO NOT EDIT — re-run `make gen`.
+
+export interface StorageAdapter {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+  clear?(): void;
+}
+
+/** Browser localStorage. Falls back to no-op on SSR / private mode. */
+export class LocalStorageAdapter implements StorageAdapter {
+  getItem(key: string): string | null {
+    if (typeof window === "undefined") return null;
+    try { return window.localStorage.getItem(key); } catch { return null; }
+  }
+  setItem(key: string, value: string): void {
+    if (typeof window === "undefined") return;
+    try { window.localStorage.setItem(key, value); } catch { /* quota / private */ }
+  }
+  removeItem(key: string): void {
+    if (typeof window === "undefined") return;
+    try { window.localStorage.removeItem(key); } catch { /* ignore */ }
+  }
+  clear(): void {
+    if (typeof window === "undefined") return;
+    try { window.localStorage.clear(); } catch { /* ignore */ }
+  }
+}
+
+/** In-memory store. Use for SSR, Electron main process, or tests. */
+export class MemoryStorageAdapter implements StorageAdapter {
+  private store = new Map<string, string>();
+  getItem(key: string): string | null { return this.store.get(key) ?? null; }
+  setItem(key: string, value: string): void { this.store.set(key, value); }
+  removeItem(key: string): void { this.store.delete(key); }
+  clear(): void { this.store.clear(); }
+}
+
+/** Cookie-backed storage (browser only). */
+export class CookieStorageAdapter implements StorageAdapter {
+  constructor(
+    private opts: {
+      domain?: string;
+      path?: string;
+      secure?: boolean;
+      sameSite?: "Strict" | "Lax" | "None";
+      maxAgeSeconds?: number;
+    } = {},
+  ) {}
+
+  getItem(key: string): string | null {
+    if (typeof document === "undefined") return null;
+    const prefix = `${encodeURIComponent(key)}=`;
+    for (const part of document.cookie.split("; ")) {
+      if (part.startsWith(prefix)) {
+        return decodeURIComponent(part.slice(prefix.length));
+      }
+    }
+    return null;
+  }
+
+  setItem(key: string, value: string): void {
+    if (typeof document === "undefined") return;
+    const parts = [
+      `${encodeURIComponent(key)}=${encodeURIComponent(value)}`,
+      `Path=${this.opts.path ?? "/"}`,
+    ];
+    if (this.opts.domain) parts.push(`Domain=${this.opts.domain}`);
+    if (this.opts.secure) parts.push("Secure");
+    if (this.opts.sameSite) parts.push(`SameSite=${this.opts.sameSite}`);
+    if (this.opts.maxAgeSeconds != null) {
+      parts.push(`Max-Age=${this.opts.maxAgeSeconds}`);
+    }
+    document.cookie = parts.join("; ");
+  }
+
+  removeItem(key: string): void {
+    if (typeof document === "undefined") return;
+    document.cookie = `${encodeURIComponent(key)}=; Max-Age=0; Path=${this.opts.path ?? "/"}`;
+  }
+}

package/src/_api/generated/_shared/validation-events.ts

@@ -0,0 +1,52 @@
+// AUTO-GENERATED by django_generator / ts_extras.wrapper
+// Browser CustomEvent integration for Zod validation errors.
+// DO NOT EDIT — re-run `make gen`.
+
+import type { ZodError } from "zod";
+
+export interface ValidationErrorDetail {
+  operation: string;
+  path: string;
+  method: string;
+  error: ZodError;
+  response: any;
+  timestamp: Date;
+}
+
+export type ValidationErrorEvent = CustomEvent<ValidationErrorDetail>;
+
+export function dispatchValidationError(detail: ValidationErrorDetail): void {
+  if (typeof window === "undefined") return;
+  try {
+    const event = new CustomEvent<ValidationErrorDetail>("zod-validation-error", {
+      detail,
+      bubbles: true,
+      cancelable: false,
+    });
+    window.dispatchEvent(event);
+  } catch (error) {
+    console.warn("Failed to dispatch validation error event:", error);
+  }
+}
+
+export function onValidationError(
+  callback: (detail: ValidationErrorDetail) => void,
+): () => void {
+  if (typeof window === "undefined") return () => {};
+  const handler = (event: Event) => {
+    if (event instanceof CustomEvent) callback(event.detail);
+  };
+  window.addEventListener("zod-validation-error", handler);
+  return () => window.removeEventListener("zod-validation-error", handler);
+}
+
+export function formatZodError(error: ZodError): string {
+  const issues = error.issues.map((issue, index) => {
+    const path = issue.path.join(".") || "root";
+    const parts = [`${index + 1}. ${path}: ${issue.message}`];
+    if ("expected" in issue && issue.expected) parts.push(`   Expected: ${issue.expected}`);
+    if ("received" in issue && issue.received) parts.push(`   Received: ${issue.received}`);
+    return parts.join("\n");
+  });
+  return issues.join("\n");
+}

package/src/_api/generated/cfg_monitor/api.ts

@@ -0,0 +1,122 @@
+// AUTO-GENERATED by django_generator / ts_extras.wrapper
+// Self-contained API wrapper for this group. DO NOT EDIT — re-run `make gen`.
+
+import { client } from './client.gen';
+import type { StorageAdapter } from '../_shared/storage';
+import { LocalStorageAdapter } from '../_shared/storage';
+import { APILogger, type LoggerConfig } from '../_shared/logger';
+
+import { Cfg } from './sdk.gen';
+import { Monitor } from './sdk.gen';
+
+
+const ACCESS_KEY = 'cfg.access_token';
+const REFRESH_KEY = 'cfg.refresh_token';
+
+
+
+/** Auto-detect locale from cookie NEXT_LOCALE or navigator.language. */
+function detectLocale(): string | null {
+  try {
+    if (typeof document !== 'undefined') {
+      const m = document.cookie.match(/(?:^|;\s*)NEXT_LOCALE=([^;]*)/);
+      if (m) return decodeURIComponent(m[1]);
+    }
+    if (typeof navigator !== 'undefined' && navigator.language) {
+      return navigator.language;
+    }
+  } catch {}
+  return null;
+}
+
+export interface APIOptions {
+  /** Override storage backend (LocalStorage by default; Memory for SSR/tests). */
+  storage?: StorageAdapter;
+  /** Logger config (defaults to dev-only). */
+  logger?: Partial<LoggerConfig>;
+  /** Locale for `Accept-Language`. If omitted, auto-detected from cookie/navigator. */
+  locale?: string;
+  /** API key sent as `X-API-Key`. Falls back to NEXT_PUBLIC_API_KEY. */
+  apiKey?: string;
+  /** Send Django session/CSRF cookies cross-origin. Defaults to true. */
+  withCredentials?: boolean;
+}
+
+/**
+ * Self-contained API wrapper for this group.
+ *
+ * Each group has its own client + interceptor + token store. The interceptor
+ * automatically attaches:
+ *   - `Authorization: Bearer <jwt>` from storage
+ *   - `Accept-Language` from `opts.locale` or `NEXT_LOCALE` cookie
+ *   - `X-API-Key` from `opts.apiKey` or `NEXT_PUBLIC_API_KEY`
+ *   - `credentials: 'include'` for Django session/CSRF cookies (toggle via opts)
+ */
+export class API {
+  private baseUrl: string;
+  private storage: StorageAdapter;
+  private locale: string | null;
+  private apiKey: string | null;
+  readonly logger: APILogger;
+
+  readonly cfg = Cfg;
+  readonly monitor = Monitor;
+
+  constructor(baseUrl: string, opts: APIOptions = {}) {
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.storage = opts.storage ?? new LocalStorageAdapter();
+    this.logger = new APILogger(opts.logger);
+    this.locale = opts.locale ?? null;
+    this.apiKey = opts.apiKey ?? (typeof process !== 'undefined' ? (process.env?.NEXT_PUBLIC_API_KEY ?? null) : null);
+
+    const credentials: RequestCredentials = (opts.withCredentials ?? true) ? 'include' : 'same-origin';
+    client.setConfig({ baseUrl: this.baseUrl, credentials });
+
+    client.interceptors.request.use((request) => {
+      const access = this.getToken();
+      if (access) request.headers.set('Authorization', `Bearer ${access}`);
+
+      const locale = this.locale ?? detectLocale();
+      if (locale) request.headers.set('Accept-Language', locale);
+
+      if (this.apiKey) request.headers.set('X-API-Key', this.apiKey);
+
+      return request;
+    });
+
+
+  }
+
+  // ── Base URL ────────────────────────────────────────────────────────────
+  getBaseUrl(): string { return this.baseUrl; }
+  setBaseUrl(url: string): void {
+    this.baseUrl = url.replace(/\/$/, '');
+    client.setConfig({ baseUrl: this.baseUrl });
+  }
+
+  // ── Tokens ──────────────────────────────────────────────────────────────
+  getToken(): string | null { return this.storage.getItem(ACCESS_KEY); }
+  setToken(token: string | null): void {
+    if (token) this.storage.setItem(ACCESS_KEY, token);
+    else this.storage.removeItem(ACCESS_KEY);
+  }
+  getRefreshToken(): string | null { return this.storage.getItem(REFRESH_KEY); }
+  setRefreshToken(token: string | null): void {
+    if (token) this.storage.setItem(REFRESH_KEY, token);
+    else this.storage.removeItem(REFRESH_KEY);
+  }
+  clearToken(): void {
+    this.storage.removeItem(ACCESS_KEY);
+    this.storage.removeItem(REFRESH_KEY);
+  }
+  isAuthenticated(): boolean { return this.getToken() !== null; }
+
+  // ── Locale / API key ────────────────────────────────────────────────────
+  getLocale(): string | null { return this.locale ?? detectLocale(); }
+  setLocale(locale: string | null): void { this.locale = locale; }
+  getApiKey(): string | null { return this.apiKey; }
+  setApiKey(key: string | null): void { this.apiKey = key; }
+}
+
+export { Cfg, Monitor };
+export { client };

package/src/_api/generated/cfg_monitor/client/client.gen.ts

@@ -0,0 +1,280 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createSseClient } from '../core/serverSentEvents.gen';
+import type { HttpMethod } from '../core/types.gen';
+import { getValidRequestBody } from '../core/utils.gen';
+import type { Client, Config, RequestOptions, ResolvedRequestOptions } from './types.gen';
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  getParseAs,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from './utils.gen';
+
+type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
+  body?: any;
+  headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    return getConfig();
+  };
+
+  const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>();
+
+  const beforeRequest = async <
+    TData = unknown,
+    TResponseStyle extends 'data' | 'fields' = 'fields',
+    ThrowOnError extends boolean = boolean,
+    Url extends string = string,
+  >(
+    options: RequestOptions<TData, TResponseStyle, ThrowOnError, Url>,
+  ) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined as string | undefined,
+    };
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body) as string | undefined;
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.body === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
+    }
+
+    const resolvedOpts = opts as typeof opts &
+      ResolvedRequestOptions<TResponseStyle, ThrowOnError, Url>;
+    const url = buildUrl(resolvedOpts);
+
+    return { opts: resolvedOpts, url };
+  };
+
+  const request: Client['request'] = async (options) => {
+    const throwOnError = options.throwOnError ?? _config.throwOnError;
+    const responseStyle = options.responseStyle ?? _config.responseStyle;
+
+    let request: Request | undefined;
+    let response: Response | undefined;
+
+    try {
+      const { opts, url } = await beforeRequest(options);
+      const requestInit: ReqInit = {
+        redirect: 'follow',
+        ...opts,
+        body: getValidRequestBody(opts),
+      };
+
+      request = new Request(url, requestInit);
+
+      for (const fn of interceptors.request.fns) {
+        if (fn) {
+          request = await fn(request, opts);
+        }
+      }
+
+      // fetch must be assigned here, otherwise it would throw the error:
+      // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+      const _fetch = opts.fetch!;
+
+      response = await _fetch(request);
+
+      for (const fn of interceptors.response.fns) {
+        if (fn) {
+          response = await fn(response, request, opts);
+        }
+      }
+
+      const result = {
+        request,
+        response,
+      };
+
+      if (response.ok) {
+        const parseAs =
+          (opts.parseAs === 'auto'
+            ? getParseAs(response.headers.get('Content-Type'))
+            : opts.parseAs) ?? 'json';
+
+        if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+          let emptyData: any;
+          switch (parseAs) {
+            case 'arrayBuffer':
+            case 'blob':
+            case 'text':
+              emptyData = await response[parseAs]();
+              break;
+            case 'formData':
+              emptyData = new FormData();
+              break;
+            case 'stream':
+              emptyData = response.body;
+              break;
+            case 'json':
+            default:
+              emptyData = {};
+              break;
+          }
+          return opts.responseStyle === 'data'
+            ? emptyData
+            : {
+                data: emptyData,
+                ...result,
+              };
+        }
+
+        let data: any;
+        switch (parseAs) {
+          case 'arrayBuffer':
+          case 'blob':
+          case 'formData':
+          case 'text':
+            data = await response[parseAs]();
+            break;
+          case 'json': {
+            // Some servers return 200 with no Content-Length and empty body.
+            // response.json() would throw; read as text and parse if non-empty.
+            const text = await response.text();
+            data = text ? JSON.parse(text) : {};
+            break;
+          }
+          case 'stream':
+            return opts.responseStyle === 'data'
+              ? response.body
+              : {
+                  data: response.body,
+                  ...result,
+                };
+        }
+
+        if (parseAs === 'json') {
+          if (opts.responseValidator) {
+            await opts.responseValidator(data);
+          }
+
+          if (opts.responseTransformer) {
+            data = await opts.responseTransformer(data);
+          }
+        }
+
+        return opts.responseStyle === 'data'
+          ? data
+          : {
+              data,
+              ...result,
+            };
+      }
+
+      const textError = await response.text();
+      let jsonError: unknown;
+
+      try {
+        jsonError = JSON.parse(textError);
+      } catch {
+        // noop
+      }
+
+      throw jsonError ?? textError;
+    } catch (error) {
+      let finalError = error;
+
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = await fn(finalError, response, request, options as ResolvedRequestOptions);
+        }
+      }
+
+      finalError = finalError || {};
+
+      if (throwOnError) {
+        throw finalError;
+      }
+
+      // TODO: we probably want to return error and improve types
+      return responseStyle === 'data'
+        ? undefined
+        : {
+            error: finalError,
+            request,
+            response,
+          };
+    }
+  };
+
+  const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+    request({ ...options, method });
+
+  const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body as BodyInit | null | undefined,
+      method,
+      onRequest: async (url, init) => {
+        let request = new Request(url, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request = await fn(request, opts);
+          }
+        }
+        return request;
+      },
+      serializedBody: getValidRequestBody(opts) as BodyInit | null | undefined,
+      url,
+    });
+  };
+
+  const _buildUrl: Client['buildUrl'] = (options) => buildUrl({ ..._config, ...options });
+
+  return {
+    buildUrl: _buildUrl,
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
+    getConfig,
+    head: makeMethodFn('HEAD'),
+    interceptors,
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn('CONNECT'),
+      delete: makeSseFn('DELETE'),
+      get: makeSseFn('GET'),
+      head: makeSseFn('HEAD'),
+      options: makeSseFn('OPTIONS'),
+      patch: makeSseFn('PATCH'),
+      post: makeSseFn('POST'),
+      put: makeSseFn('PUT'),
+      trace: makeSseFn('TRACE'),
+    },
+    trace: makeMethodFn('TRACE'),
+  } as Client;
+};

package/src/_api/generated/cfg_monitor/client/index.ts

@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export { createClient } from './client.gen';
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';