@devpad/api 2.0.1 → 2.0.3

package/dist/chunk-5X36WMYQ.js

@@ -0,0 +1,130 @@
+// ../schema/dist/errors.js
+import { err } from "@f0rbit/corpus";
+var defaultLogger = ({ error, context }) => {
+  console.error(`[${context.timestamp}] [${error.kind}]`, error.message || error.kind, { ...error, stack: context.stack?.split("\n").slice(2, 5).join("\n"), ...context });
+};
+var errorLogger = defaultLogger;
+var contextProvider = null;
+var configureErrorLogging = (config) => {
+  if (config.logger)
+    errorLogger = config.logger;
+  if (config.contextProvider)
+    contextProvider = config.contextProvider;
+};
+var logAndReturn = (error, ctx) => {
+  const context = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), stack: new Error().stack, ...contextProvider?.(), ...ctx };
+  errorLogger({ error, context });
+  return err(error);
+};
+var hasKind = (e, kind) => typeof e === "object" && e !== null && "kind" in e && e.kind === kind;
+var isNotFoundError = (e) => hasKind(e, "not_found");
+var isForbiddenError = (e) => hasKind(e, "forbidden");
+var isValidationError = (e) => hasKind(e, "validation");
+var isRateLimitedError = (e) => hasKind(e, "rate_limited");
+var isStoreError = (e) => hasKind(e, "store_error");
+var isNetworkError = (e) => hasKind(e, "network_error");
+var isAuthExpiredError = (e) => hasKind(e, "auth_expired");
+var isApiError = (e) => hasKind(e, "api_error");
+var isParseError = (e) => hasKind(e, "parse_error");
+var isEncryptionError = (e) => hasKind(e, "encryption_error");
+var isDatabaseError = (e) => hasKind(e, "db_error");
+var isConflictError = (e) => hasKind(e, "conflict");
+var isBadRequestError = (e) => hasKind(e, "bad_request");
+var isUnauthorizedError = (e) => hasKind(e, "unauthorized");
+var isScanError = (e) => hasKind(e, "scan_error");
+var isGithubError = (e) => hasKind(e, "github_error");
+var isServiceError = (e) => isNotFoundError(e) || isForbiddenError(e) || isValidationError(e) || isRateLimitedError(e) || isStoreError(e) || isNetworkError(e) || isAuthExpiredError(e) || isApiError(e) || isParseError(e) || isEncryptionError(e) || isDatabaseError(e) || isConflictError(e) || isBadRequestError(e) || isUnauthorizedError(e) || isScanError(e) || isGithubError(e);
+var isRetryableError = (e) => isRateLimitedError(e) || isNetworkError(e);
+var notFound = (resource, id, ctx) => logAndReturn({ kind: "not_found", resource, ...id && { id } }, ctx);
+var forbidden = (reason, ctx) => logAndReturn({ kind: "forbidden", ...reason && { reason, message: reason } }, ctx);
+var validation = (errors2, ctx) => logAndReturn({ kind: "validation", errors: errors2 }, ctx);
+var rateLimited = (retry_after, ctx) => logAndReturn({ kind: "rate_limited", ...retry_after !== void 0 && { retry_after } }, ctx);
+var storeError = (operation, message, ctx) => logAndReturn({ kind: "store_error", operation, ...message && { message } }, ctx);
+var networkError = (cause, message, ctx) => logAndReturn({ kind: "network_error", ...cause && { cause }, ...message && { message } }, ctx);
+var authExpired = (message, ctx) => logAndReturn({ kind: "auth_expired", ...message && { message } }, ctx);
+var apiError = (status, message, ctx) => logAndReturn({ kind: "api_error", status, ...message && { message } }, ctx);
+var parseError = (message, ctx) => logAndReturn({ kind: "parse_error", ...message && { message } }, ctx);
+var encryptionError = (operation, message, ctx) => logAndReturn({ kind: "encryption_error", operation, ...message && { message } }, ctx);
+var dbError = (message, ctx) => logAndReturn({ kind: "db_error", ...message && { message } }, ctx);
+var conflict = (resource, message, ctx) => logAndReturn({ kind: "conflict", ...resource && { resource }, ...message && { message } }, ctx);
+var badRequest = (message, details, ctx) => logAndReturn({ kind: "bad_request", ...message && { message }, ...details !== void 0 && { details } }, ctx);
+var unauthorized = (message, ctx) => logAndReturn({ kind: "unauthorized", ...message && { message } }, ctx);
+var scanError = (message, ctx) => logAndReturn({ kind: "scan_error", ...message && { message } }, ctx);
+var githubError = (message, ctx) => logAndReturn({ kind: "github_error", ...message && { message } }, ctx);
+var errors = {
+  notFound,
+  forbidden,
+  validation,
+  rateLimited,
+  storeError,
+  networkError,
+  authExpired,
+  apiError,
+  parseError,
+  encryptionError,
+  dbError,
+  conflict,
+  badRequest,
+  unauthorized,
+  scanError,
+  githubError,
+  is: {
+    notFound: isNotFoundError,
+    forbidden: isForbiddenError,
+    validation: isValidationError,
+    rateLimited: isRateLimitedError,
+    storeError: isStoreError,
+    networkError: isNetworkError,
+    authExpired: isAuthExpiredError,
+    apiError: isApiError,
+    parseError: isParseError,
+    encryptionError: isEncryptionError,
+    dbError: isDatabaseError,
+    conflict: isConflictError,
+    badRequest: isBadRequestError,
+    unauthorized: isUnauthorizedError,
+    scanError: isScanError,
+    githubError: isGithubError,
+    serviceError: isServiceError,
+    retryable: isRetryableError
+  }
+};
+
+export {
+  configureErrorLogging,
+  isNotFoundError,
+  isForbiddenError,
+  isValidationError,
+  isRateLimitedError,
+  isStoreError,
+  isNetworkError,
+  isAuthExpiredError,
+  isApiError,
+  isParseError,
+  isEncryptionError,
+  isDatabaseError,
+  isConflictError,
+  isBadRequestError,
+  isUnauthorizedError,
+  isScanError,
+  isGithubError,
+  isServiceError,
+  isRetryableError,
+  notFound,
+  forbidden,
+  validation,
+  rateLimited,
+  storeError,
+  networkError,
+  authExpired,
+  apiError,
+  parseError,
+  encryptionError,
+  dbError,
+  conflict,
+  badRequest,
+  unauthorized,
+  scanError,
+  githubError,
+  errors
+};

package/dist/chunk-INGCIUMX.js

@@ -0,0 +1,166 @@
+// ../schema/dist/types.js
+var TAG_COLOURS = {
+  red: { colour: "#F28B82", text: "#faeeef", border: "#F5A5A5" },
+  green: { colour: "#CCFF90", text: "#2E7D32", border: "#A5D6A7" },
+  blue: { colour: "#82B1FF", text: "#0D47A1", border: "#90CAF9" },
+  yellow: { colour: "#FFF176", text: "#F57F17", border: "#FFF59D" },
+  purple: { colour: "#E1BEE7", text: "#4A148C", border: "#CE93D8" },
+  orange: { colour: "#FFCC80", text: "#E65100", border: "#FFB74D" },
+  teal: { colour: "#80CBC4", text: "#004D40", border: "#4DB6AC" },
+  pink: { colour: "#F8BBD9", text: "#880E4F", border: "#F48FB1" },
+  gray: { colour: "#CFD8DC", text: "#37474F", border: "#B0BEC5" },
+  cyan: { colour: "#84FFFF", text: "#006064", border: "#4DD0E1" },
+  lime: { colour: "#ddf0bc", text: "#88b47f", border: "#becca5" }
+};
+var ArrayBufferedQueue = class {
+  constructor(_capacity) {
+    this._capacity = _capacity;
+    this._entries = [];
+    this._head = 0;
+    this._tail = 0;
+    this._size = 0;
+  }
+  latest() {
+    if (this._size === 0)
+      return null;
+    return this._entries[this._tail - 1] ?? null;
+  }
+  list() {
+    if (this._size === 0)
+      return [];
+    if (this._head < this._tail) {
+      return this._entries.slice(this._head, this._tail);
+    }
+    return this._entries.slice(this._head).concat(this._entries.slice(0, this._tail));
+  }
+  add(item) {
+    if (this._size === this._capacity) {
+      this._head = (this._head + 1) % this._capacity;
+    } else {
+      this._size++;
+    }
+    this._entries[this._tail] = item;
+    this._tail = (this._tail + 1) % this._capacity;
+  }
+  size() {
+    return this._size;
+  }
+  clear() {
+    this._entries = [];
+    this._head = 0;
+    this._tail = 0;
+    this._size = 0;
+  }
+};
+
+// ../schema/dist/validation.js
+import { z } from "zod";
+var upsert_project = z.object({
+  id: z.string().optional().nullable(),
+  project_id: z.string(),
+  owner_id: z.string().optional(),
+  name: z.string(),
+  description: z.string().nullable(),
+  specification: z.string().nullable(),
+  repo_url: z.string().nullable(),
+  repo_id: z.number().nullable(),
+  icon_url: z.string().nullable(),
+  status: z.union([z.literal("DEVELOPMENT"), z.literal("PAUSED"), z.literal("RELEASED"), z.literal("LIVE"), z.literal("FINISHED"), z.literal("ABANDONED"), z.literal("STOPPED")]).optional(),
+  deleted: z.boolean().optional().default(false),
+  link_url: z.string().nullable(),
+  link_text: z.string().nullable(),
+  visibility: z.union([z.literal("PUBLIC"), z.literal("PRIVATE"), z.literal("HIDDEN"), z.literal("ARCHIVED"), z.literal("DRAFT"), z.literal("DELETED")]).optional(),
+  current_version: z.string().nullable()
+});
+var upsert_todo = z.object({
+  id: z.string().optional().nullable(),
+  title: z.string().optional(),
+  summary: z.string().optional().nullable(),
+  description: z.string().optional().nullable(),
+  progress: z.union([z.literal("UNSTARTED"), z.literal("IN_PROGRESS"), z.literal("COMPLETED")]).optional(),
+  visibility: z.union([z.literal("PUBLIC"), z.literal("PRIVATE"), z.literal("HIDDEN"), z.literal("ARCHIVED"), z.literal("DRAFT"), z.literal("DELETED")]).optional(),
+  start_time: z.string().optional().nullable(),
+  end_time: z.string().optional().nullable(),
+  priority: z.union([z.literal("LOW"), z.literal("MEDIUM"), z.literal("HIGH")]).optional(),
+  owner_id: z.string(),
+  project_id: z.string().optional().nullable(),
+  goal_id: z.string().optional().nullable()
+});
+var update_action = z.union([z.literal("CONFIRM"), z.literal("UNLINK"), z.literal("CREATE"), z.literal("IGNORE"), z.literal("DELETE"), z.literal("COMPLETE")]);
+var ConfigSchema = z.object({
+  tags: z.array(z.object({
+    name: z.string(),
+    match: z.array(z.string())
+  })),
+  ignore: z.array(z.string().regex(/^[^]*$/, "Invalid path"))
+});
+var upsert_tag = z.object({
+  id: z.string().optional(),
+  title: z.string(),
+  color: z.union([z.literal("red"), z.literal("green"), z.literal("blue"), z.literal("yellow"), z.literal("purple"), z.literal("orange"), z.literal("teal"), z.literal("pink"), z.literal("gray"), z.literal("cyan"), z.literal("lime")]).nullable().optional(),
+  deleted: z.boolean().optional().default(false),
+  render: z.boolean().optional().default(true),
+  owner_id: z.string()
+});
+var project_config = z.object({
+  tags: z.array(z.object({
+    name: z.string(),
+    match: z.array(z.string())
+  })),
+  ignore: z.array(z.string())
+});
+var save_config_request = z.object({
+  id: z.string(),
+  config: project_config,
+  scan_branch: z.string().optional()
+});
+var save_tags_request = z.array(upsert_tag);
+var update_user = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  image_url: z.string().optional(),
+  task_view: z.union([z.literal("list"), z.literal("grid")]).optional(),
+  email_verified: z.boolean().optional()
+});
+var config_schema = z.object({
+  tags: z.array(z.object({
+    name: z.string(),
+    match: z.array(z.string())
+  })),
+  ignore: z.array(z.string().regex(/^[^]*$/, "Invalid path"))
+});
+var upsert_milestone = z.object({
+  id: z.string().optional().nullable(),
+  project_id: z.string(),
+  name: z.string().min(1).max(200),
+  description: z.string().nullable().optional(),
+  target_time: z.string().nullable().optional(),
+  target_version: z.string().nullable().optional(),
+  finished_at: z.string().nullable().optional(),
+  after_id: z.string().nullable().optional()
+});
+var upsert_goal = z.object({
+  id: z.string().optional().nullable(),
+  milestone_id: z.string(),
+  name: z.string().min(1).max(200),
+  description: z.string().nullable().optional(),
+  target_time: z.string().nullable().optional(),
+  finished_at: z.string().nullable().optional()
+});
+
+export {
+  TAG_COLOURS,
+  ArrayBufferedQueue,
+  upsert_project,
+  upsert_todo,
+  update_action,
+  ConfigSchema,
+  upsert_tag,
+  project_config,
+  save_config_request,
+  save_tags_request,
+  update_user,
+  config_schema,
+  upsert_milestone,
+  upsert_goal
+};

package/dist/errors.d-C73AkrdX.d.ts

@@ -0,0 +1,159 @@
+import { Result } from '@f0rbit/corpus';
+
+type BaseError = {
+    kind: string;
+    message?: string;
+};
+type NotFoundError = BaseError & {
+    kind: "not_found";
+    resource: string;
+    id?: string;
+};
+type ForbiddenError = BaseError & {
+    kind: "forbidden";
+    reason?: string;
+};
+type ValidationError = BaseError & {
+    kind: "validation";
+    errors: Record<string, string[]>;
+};
+type RateLimitedError = BaseError & {
+    kind: "rate_limited";
+    retry_after?: number;
+};
+type StoreError = BaseError & {
+    kind: "store_error";
+    operation: string;
+};
+type NetworkError = BaseError & {
+    kind: "network_error";
+    cause?: Error;
+};
+type AuthExpiredError = BaseError & {
+    kind: "auth_expired";
+};
+type ApiError = BaseError & {
+    kind: "api_error";
+    status: number;
+};
+type ParseError = BaseError & {
+    kind: "parse_error";
+};
+type EncryptionError = BaseError & {
+    kind: "encryption_error";
+    operation: "encrypt" | "decrypt";
+};
+type DatabaseError = BaseError & {
+    kind: "db_error";
+};
+type ConflictError = BaseError & {
+    kind: "conflict";
+    resource?: string;
+};
+type BadRequestError = BaseError & {
+    kind: "bad_request";
+    details?: unknown;
+};
+type UnauthorizedError = BaseError & {
+    kind: "unauthorized";
+};
+type ScanError = BaseError & {
+    kind: "scan_error";
+};
+type GithubError = BaseError & {
+    kind: "github_error";
+};
+type ServiceError = NotFoundError | ForbiddenError | ValidationError | RateLimitedError | StoreError | NetworkError | AuthExpiredError | ApiError | ParseError | EncryptionError | DatabaseError | ConflictError | BadRequestError | UnauthorizedError | ScanError | GithubError;
+type ProviderError = RateLimitedError | AuthExpiredError | NetworkError | ApiError | ParseError;
+type CronError = StoreError | NetworkError | AuthExpiredError | EncryptionError;
+type ErrorContext = {
+    timestamp: string;
+    stack?: string;
+    requestId?: string;
+    userId?: string;
+    operation?: string;
+    [key: string]: unknown;
+};
+type ErrorLogEntry = {
+    error: ServiceError;
+    context: ErrorContext;
+};
+type ErrorLogFn = (entry: ErrorLogEntry) => void;
+declare const configureErrorLogging: (config: {
+    logger?: ErrorLogFn;
+    contextProvider?: () => Partial<ErrorContext>;
+}) => void;
+declare const isNotFoundError: (e: unknown) => e is NotFoundError;
+declare const isForbiddenError: (e: unknown) => e is ForbiddenError;
+declare const isValidationError: (e: unknown) => e is ValidationError;
+declare const isRateLimitedError: (e: unknown) => e is RateLimitedError;
+declare const isStoreError: (e: unknown) => e is StoreError;
+declare const isNetworkError: (e: unknown) => e is NetworkError;
+declare const isAuthExpiredError: (e: unknown) => e is AuthExpiredError;
+declare const isApiError: (e: unknown) => e is ApiError;
+declare const isParseError: (e: unknown) => e is ParseError;
+declare const isEncryptionError: (e: unknown) => e is EncryptionError;
+declare const isDatabaseError: (e: unknown) => e is DatabaseError;
+declare const isConflictError: (e: unknown) => e is ConflictError;
+declare const isBadRequestError: (e: unknown) => e is BadRequestError;
+declare const isUnauthorizedError: (e: unknown) => e is UnauthorizedError;
+declare const isScanError: (e: unknown) => e is ScanError;
+declare const isGithubError: (e: unknown) => e is GithubError;
+declare const isServiceError: (e: unknown) => e is ServiceError;
+declare const isRetryableError: (e: unknown) => boolean;
+declare const notFound: (resource: string, id?: string, ctx?: Record<string, unknown>) => Result<never, NotFoundError>;
+declare const forbidden: (reason?: string, ctx?: Record<string, unknown>) => Result<never, ForbiddenError>;
+declare const validation: (errors: Record<string, string[]>, ctx?: Record<string, unknown>) => Result<never, ValidationError>;
+declare const rateLimited: (retry_after?: number, ctx?: Record<string, unknown>) => Result<never, RateLimitedError>;
+declare const storeError: (operation: string, message?: string, ctx?: Record<string, unknown>) => Result<never, StoreError>;
+declare const networkError: (cause?: Error, message?: string, ctx?: Record<string, unknown>) => Result<never, NetworkError>;
+declare const authExpired: (message?: string, ctx?: Record<string, unknown>) => Result<never, AuthExpiredError>;
+declare const apiError: (status: number, message?: string, ctx?: Record<string, unknown>) => Result<never, ApiError>;
+declare const parseError: (message?: string, ctx?: Record<string, unknown>) => Result<never, ParseError>;
+declare const encryptionError: (operation: "encrypt" | "decrypt", message?: string, ctx?: Record<string, unknown>) => Result<never, EncryptionError>;
+declare const dbError: (message?: string, ctx?: Record<string, unknown>) => Result<never, DatabaseError>;
+declare const conflict: (resource?: string, message?: string, ctx?: Record<string, unknown>) => Result<never, ConflictError>;
+declare const badRequest: (message?: string, details?: unknown, ctx?: Record<string, unknown>) => Result<never, BadRequestError>;
+declare const unauthorized: (message?: string, ctx?: Record<string, unknown>) => Result<never, UnauthorizedError>;
+declare const scanError: (message?: string, ctx?: Record<string, unknown>) => Result<never, ScanError>;
+declare const githubError: (message?: string, ctx?: Record<string, unknown>) => Result<never, GithubError>;
+declare const errors: {
+    readonly notFound: (resource: string, id?: string, ctx?: Record<string, unknown>) => Result<never, NotFoundError>;
+    readonly forbidden: (reason?: string, ctx?: Record<string, unknown>) => Result<never, ForbiddenError>;
+    readonly validation: (errors: Record<string, string[]>, ctx?: Record<string, unknown>) => Result<never, ValidationError>;
+    readonly rateLimited: (retry_after?: number, ctx?: Record<string, unknown>) => Result<never, RateLimitedError>;
+    readonly storeError: (operation: string, message?: string, ctx?: Record<string, unknown>) => Result<never, StoreError>;
+    readonly networkError: (cause?: Error, message?: string, ctx?: Record<string, unknown>) => Result<never, NetworkError>;
+    readonly authExpired: (message?: string, ctx?: Record<string, unknown>) => Result<never, AuthExpiredError>;
+    readonly apiError: (status: number, message?: string, ctx?: Record<string, unknown>) => Result<never, ApiError>;
+    readonly parseError: (message?: string, ctx?: Record<string, unknown>) => Result<never, ParseError>;
+    readonly encryptionError: (operation: "encrypt" | "decrypt", message?: string, ctx?: Record<string, unknown>) => Result<never, EncryptionError>;
+    readonly dbError: (message?: string, ctx?: Record<string, unknown>) => Result<never, DatabaseError>;
+    readonly conflict: (resource?: string, message?: string, ctx?: Record<string, unknown>) => Result<never, ConflictError>;
+    readonly badRequest: (message?: string, details?: unknown, ctx?: Record<string, unknown>) => Result<never, BadRequestError>;
+    readonly unauthorized: (message?: string, ctx?: Record<string, unknown>) => Result<never, UnauthorizedError>;
+    readonly scanError: (message?: string, ctx?: Record<string, unknown>) => Result<never, ScanError>;
+    readonly githubError: (message?: string, ctx?: Record<string, unknown>) => Result<never, GithubError>;
+    readonly is: {
+        readonly notFound: (e: unknown) => e is NotFoundError;
+        readonly forbidden: (e: unknown) => e is ForbiddenError;
+        readonly validation: (e: unknown) => e is ValidationError;
+        readonly rateLimited: (e: unknown) => e is RateLimitedError;
+        readonly storeError: (e: unknown) => e is StoreError;
+        readonly networkError: (e: unknown) => e is NetworkError;
+        readonly authExpired: (e: unknown) => e is AuthExpiredError;
+        readonly apiError: (e: unknown) => e is ApiError;
+        readonly parseError: (e: unknown) => e is ParseError;
+        readonly encryptionError: (e: unknown) => e is EncryptionError;
+        readonly dbError: (e: unknown) => e is DatabaseError;
+        readonly conflict: (e: unknown) => e is ConflictError;
+        readonly badRequest: (e: unknown) => e is BadRequestError;
+        readonly unauthorized: (e: unknown) => e is UnauthorizedError;
+        readonly scanError: (e: unknown) => e is ScanError;
+        readonly githubError: (e: unknown) => e is GithubError;
+        readonly serviceError: (e: unknown) => e is ServiceError;
+        readonly retryable: (e: unknown) => boolean;
+    };
+};
+
+export { badRequest as $, type AuthExpiredError as A, type BaseError as B, type ConflictError as C, type DatabaseError as D, type EncryptionError as E, type ForbiddenError as F, type GithubError as G, isServiceError as H, isRetryableError as I, notFound as J, forbidden as K, validation as L, rateLimited as M, type NotFoundError as N, storeError as O, type ParseError as P, networkError as Q, type RateLimitedError as R, type StoreError as S, authExpired as T, type UnauthorizedError as U, type ValidationError as V, apiError as W, parseError as X, encryptionError as Y, dbError as Z, conflict as _, type NetworkError as a, unauthorized as a0, scanError as a1, githubError as a2, errors as a3, type ApiError as b, type BadRequestError as c, type ScanError as d, type ServiceError as e, type ProviderError as f, type CronError as g, type ErrorContext as h, type ErrorLogEntry as i, configureErrorLogging as j, isNotFoundError as k, isForbiddenError as l, isValidationError as m, isRateLimitedError as n, isStoreError as o, isNetworkError as p, isAuthExpiredError as q, isApiError as r, isParseError as s, isEncryptionError as t, isDatabaseError as u, isConflictError as v, isBadRequestError as w, isUnauthorizedError as x, isScanError as y, isGithubError as z };