@devpad/api 2.0.3 → 2.0.4

package/dist/{chunk-5X36WMYQ.js → chunk-5ALH7B5B.js}

@@ -29,11 +29,12 @@ 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 isProtectedError = (e) => hasKind(e, "protected");
 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 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) || isProtectedError(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);
@@ -47,6 +48,7 @@ var parseError = (message, ctx) => logAndReturn({ kind: "parse_error", ...messag
 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 protectedEntity = (entity_id, message, modified_by, modified_at, ctx) => logAndReturn({ kind: "protected", ...entity_id && { entity_id }, ...message && { message }, ...modified_by && { modified_by }, ...modified_at && { modified_at } }, 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);
@@ -64,6 +66,7 @@ var errors = {
   encryptionError,
   dbError,
   conflict,
+  protectedEntity,
   badRequest,
   unauthorized,
   scanError,
@@ -81,6 +84,7 @@ var errors = {
     encryptionError: isEncryptionError,
     dbError: isDatabaseError,
     conflict: isConflictError,
+    protectedEntity: isProtectedError,
     badRequest: isBadRequestError,
     unauthorized: isUnauthorizedError,
     scanError: isScanError,
@@ -104,6 +108,7 @@ export {
   isEncryptionError,
   isDatabaseError,
   isConflictError,
+  isProtectedError,
   isBadRequestError,
   isUnauthorizedError,
   isScanError,
@@ -122,6 +127,7 @@ export {
   encryptionError,
   dbError,
   conflict,
+  protectedEntity,
   badRequest,
   unauthorized,
   scanError,

package/dist/{chunk-INGCIUMX.js → chunk-XGQQPYSB.js}

@@ -70,7 +70,8 @@ var upsert_project = z.object({
   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()
+  current_version: z.string().nullable(),
+  force: z.boolean().optional().describe("Override protection on user-modified entities")
 });
 var upsert_todo = z.object({
   id: z.string().optional().nullable(),
@@ -84,7 +85,8 @@ var upsert_todo = z.object({
   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()
+  goal_id: z.string().optional().nullable(),
+  force: z.boolean().optional().describe("Override protection on user-modified entities")
 });
 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({
@@ -137,7 +139,8 @@ var upsert_milestone = z.object({
   target_time: z.string().nullable().optional(),
   target_version: z.string().nullable().optional(),
   finished_at: z.string().nullable().optional(),
-  after_id: z.string().nullable().optional()
+  after_id: z.string().nullable().optional(),
+  force: z.boolean().optional().describe("Override protection on user-modified entities")
 });
 var upsert_goal = z.object({
   id: z.string().optional().nullable(),
@@ -145,7 +148,8 @@ var upsert_goal = z.object({
   name: z.string().min(1).max(200),
   description: z.string().nullable().optional(),
   target_time: z.string().nullable().optional(),
-  finished_at: z.string().nullable().optional()
+  finished_at: z.string().nullable().optional(),
+  force: z.boolean().optional().describe("Override protection on user-modified entities")
 });
 
 export {

package/dist/{errors.d-C73AkrdX.d.ts → errors.d-DcjQAql-.d.ts}

@@ -50,6 +50,12 @@ type ConflictError = BaseError & {
     kind: "conflict";
     resource?: string;
 };
+type ProtectedError = BaseError & {
+    kind: "protected";
+    entity_id?: string;
+    modified_by?: string;
+    modified_at?: string;
+};
 type BadRequestError = BaseError & {
     kind: "bad_request";
     details?: unknown;
@@ -63,7 +69,7 @@ type ScanError = BaseError & {
 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 ServiceError = NotFoundError | ForbiddenError | ValidationError | RateLimitedError | StoreError | NetworkError | AuthExpiredError | ApiError | ParseError | EncryptionError | DatabaseError | ConflictError | ProtectedError | BadRequestError | UnauthorizedError | ScanError | GithubError;
 type ProviderError = RateLimitedError | AuthExpiredError | NetworkError | ApiError | ParseError;
 type CronError = StoreError | NetworkError | AuthExpiredError | EncryptionError;
 type ErrorContext = {
@@ -95,6 +101,7 @@ 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 isProtectedError: (e: unknown) => e is ProtectedError;
 declare const isBadRequestError: (e: unknown) => e is BadRequestError;
 declare const isUnauthorizedError: (e: unknown) => e is UnauthorizedError;
 declare const isScanError: (e: unknown) => e is ScanError;
@@ -113,6 +120,7 @@ declare const parseError: (message?: string, ctx?: Record<string, unknown>) => R
 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 protectedEntity: (entity_id?: string, message?: string, modified_by?: string, modified_at?: string, ctx?: Record<string, unknown>) => Result<never, ProtectedError>;
 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>;
@@ -130,6 +138,7 @@ declare const errors: {
     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 protectedEntity: (entity_id?: string, message?: string, modified_by?: string, modified_at?: string, ctx?: Record<string, unknown>) => Result<never, ProtectedError>;
     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>;
@@ -147,6 +156,7 @@ declare const errors: {
         readonly encryptionError: (e: unknown) => e is EncryptionError;
         readonly dbError: (e: unknown) => e is DatabaseError;
         readonly conflict: (e: unknown) => e is ConflictError;
+        readonly protectedEntity: (e: unknown) => e is ProtectedError;
         readonly badRequest: (e: unknown) => e is BadRequestError;
         readonly unauthorized: (e: unknown) => e is UnauthorizedError;
         readonly scanError: (e: unknown) => e is ScanError;
@@ -156,4 +166,4 @@ declare const errors: {
     };
 };
 
-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 };
+export { dbError 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, isScanError as H, isGithubError as I, isServiceError as J, isRetryableError as K, notFound as L, forbidden as M, type NotFoundError as N, validation as O, type ParseError as P, rateLimited as Q, type RateLimitedError as R, type StoreError as S, storeError as T, type UnauthorizedError as U, type ValidationError as V, networkError as W, authExpired as X, apiError as Y, parseError as Z, encryptionError as _, type NetworkError as a, conflict as a0, protectedEntity as a1, badRequest as a2, unauthorized as a3, scanError as a4, githubError as a5, errors as a6, type ApiError as b, type ProtectedError as c, type BadRequestError as d, type ScanError as e, type ServiceError as f, type ProviderError as g, type CronError as h, type ErrorContext as i, type ErrorLogEntry as j, configureErrorLogging as k, isNotFoundError as l, isForbiddenError as m, isValidationError as n, isRateLimitedError as o, isStoreError as p, isNetworkError as q, isAuthExpiredError as r, isApiError as s, isParseError as t, isEncryptionError as u, isDatabaseError as v, isConflictError as w, isProtectedError as x, isBadRequestError as y, isUnauthorizedError as z };

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { A as ApiKey, P as Project, v as UpsertProject, L as GetConfigResult, E as SaveConfigRequest, M as Milestone, G as Goal, H as TaskWithDetails, w as UpsertTodo, x as UpsertTag, $ as HistoryAction, Q as TagWithTypedColor, a4 as BufferedQueue } from './types.d-Bj4FU9Op.js';
-export { D as ProjectConfig, T as Task } from './types.d-Bj4FU9Op.js';
+import { A as ApiKey, P as Project, v as UpsertProject, L as GetConfigResult, E as SaveConfigRequest, M as Milestone, G as Goal, H as TaskWithDetails, w as UpsertTodo, x as UpsertTag, $ as HistoryAction, Q as TagWithTypedColor, a4 as BufferedQueue } from './types.d-CeY2wsr4.js';
+export { D as ProjectConfig, T as Task } from './types.d-CeY2wsr4.js';
 import { Q as PostListParams, S as PostsResponse, J as Post, L as PostCreate, N as PostUpdate, d as VersionInfo, a as PostContent, k as Category, $ as CategoryCreate, v as AccessKey } from './types.d-DLE9TSql.js';
-import { T as Profile, a4 as CreateProfileInput, a5 as UpdateProfileInput, U as ProfileFilter, a6 as AddFilterInput, aI as Timeline, A as Account, ai as PlatformSettings } from './types.d-B1VbnHQT.js';
+import { T as Profile, a4 as CreateProfileInput, a5 as UpdateProfileInput, U as ProfileFilter, a6 as AddFilterInput, aI as Timeline, A as Account, ai as PlatformSettings } from './types.d-BgSkvLhS.js';
 import { Result } from '@f0rbit/corpus';
 export { Result, err, ok } from '@f0rbit/corpus';
 import { z } from 'zod';
 import 'drizzle-orm';
-import './schema.d-DALWdx-o.js';
+import './schema.d-DcPuyqgh.js';
 import 'drizzle-orm/sqlite-core';
 import './media.d-CQ56ckoR.js';
 
@@ -473,6 +473,14 @@ declare class ApiClient {
     /**
      * User namespace with Result-wrapped operations
      */
+    readonly activity: {
+        ai: (options?: {
+            limit?: number;
+            since?: string;
+        }) => Promise<ApiResult<{
+            sessions: any[];
+        }>>;
+    };
     readonly user: {
         /**
          * Get user activity history