@devpad/api 2.0.1 → 2.0.3

package/dist/api-client.js

@@ -1,530 +0,0 @@
-import { ApiClient as HttpClient } from "./request";
-import { wrap } from "./result";
-/**
- * API client with Result-wrapped operations for clean error handling
- * All methods return ApiResult<T> types using @f0rbit/corpus Result
- */
-export class ApiClient {
-    constructor(options) {
-        /**
-         * Auth namespace with Result-wrapped operations
-         */
-        this.auth = {
-            session: () => wrap(() => this.clients.auth_root.get("/auth/session")),
-            keys: {
-                list: () => wrap(() => this.clients.auth.get("/keys")),
-                create: (name) => wrap(() => this.clients.auth.post("/keys", { body: name ? { name } : {} })),
-                revoke: (key_id) => wrap(() => this.clients.auth.delete(`/keys/${key_id}`)),
-                remove: (key_id) => wrap(() => this.clients.auth.delete(`/keys/${key_id}`)),
-            },
-        };
-        /**
-         * Projects namespace with Result-wrapped operations
-         */
-        this.projects = {
-            /**
-             * List projects with optional filtering
-             */
-            list: (filters) => wrap(() => this.clients.projects.get(filters?.private === false ? "/projects/public" : "/projects")),
-            /**
-             * Get project map
-             */
-            map: async (filters) => wrap(async () => {
-                const result = await this.projects.list(filters);
-                if (!result.ok)
-                    throw new Error(result.error.message);
-                return result.value.reduce((acc, project) => {
-                    acc[project.id] = project;
-                    return acc;
-                }, {});
-            }),
-            /**
-             * Get project by ID
-             */
-            find: (id) => wrap(() => this.clients.projects.get("/projects", { query: { id } })),
-            /**
-             * Get project by name
-             */
-            getByName: (name) => wrap(() => this.clients.projects.get("/projects", { query: { name } })),
-            /**
-             * Get project by ID (throws if not found)
-             */
-            getById: (id) => wrap(() => this.clients.projects.get("/projects", { query: { id } })),
-            /**
-             * Create a new project
-             */
-            create: (data) => wrap(() => this.clients.projects.patch("/projects", { body: data })),
-            /**
-             * Update an existing project
-             */
-            update: async (idOrData, changes) => wrap(async () => {
-                // Handle backward compatibility: update(data)
-                if (typeof idOrData === "object" && idOrData.id) {
-                    return this.clients.projects.patch("/projects", { body: idOrData });
-                }
-                // Handle new clean interface: update(id, changes)
-                const id = idOrData;
-                if (!changes) {
-                    throw new Error("Changes parameter required for update");
-                }
-                // Fetch the existing project to get current values
-                const result = await this.projects.find(id);
-                if (!result.ok)
-                    throw new Error(result.error.message);
-                if (!result.value)
-                    throw new Error(`Project with id ${id} not found`);
-                const project = result.value;
-                // Merge changes with existing project data
-                const updateData = {
-                    id: project.id,
-                    project_id: project.project_id,
-                    owner_id: project.owner_id,
-                    name: project.name,
-                    description: project.description,
-                    specification: project.specification,
-                    repo_url: project.repo_url,
-                    repo_id: project.repo_id,
-                    icon_url: project.icon_url,
-                    status: project.status,
-                    deleted: project.deleted,
-                    link_url: project.link_url,
-                    link_text: project.link_text,
-                    visibility: project.visibility,
-                    current_version: project.current_version,
-                    ...changes,
-                };
-                return this.clients.projects.patch("/projects", { body: updateData });
-            }),
-            /**
-             * Project configuration operations
-             */
-            config: {
-                /**
-                 * Get project configuration
-                 */
-                load: (project_id) => wrap(() => this.clients.projects.get("/projects/config", { query: { project_id } })),
-                /**
-                 * Save project configuration
-                 */
-                save: (request) => wrap(() => this.clients.projects.patch("/projects/save_config", { body: request })),
-            },
-            /**
-             * Scanning operations
-             */
-            scan: {
-                /**
-                 * Initiate a repository scan (returns stream)
-                 */
-                initiate: async (project_id) => {
-                    const response = await fetch(`${this.clients.projects.url()}/projects/scan?project_id=${project_id}`, {
-                        method: "POST",
-                        headers: this.clients.projects.headers(),
-                    });
-                    if (!response.body) {
-                        throw new Error("No response body");
-                    }
-                    const stream = response.body.pipeThrough(new TextDecoderStream());
-                    return stream;
-                },
-                /**
-                 * Get pending scan updates for a project
-                 */
-                updates: (project_id) => wrap(() => this.clients.projects.get("/projects/updates", { query: { project_id } }).then(response => response.updates)),
-                /**
-                 * Process scan results
-                 */
-                update: (project_id, data) => wrap(() => this.clients.projects.post("/projects/scan_status", { query: { project_id }, body: data })),
-            },
-            /**
-             * Get project history
-             */
-            history: (project_id) => wrap(() => this.clients.projects.get(`/projects/${project_id}/history`)),
-            /**
-             * Legacy methods (keeping for compatibility)
-             */
-            upsert: (data) => wrap(() => this.clients.projects.patch("/projects", { body: data })),
-            /**
-             * Fetch project specification from GitHub
-             */
-            specification: (project_id) => wrap(() => this.clients.projects.get("/projects/fetch_spec", { query: { project_id } })),
-            /**
-             * Delete project (soft delete)
-             */
-            deleteProject: (project) => wrap(() => this.clients.projects.patch("/projects", { body: { ...project, deleted: true } })),
-        };
-        /**
-         * Milestones namespace with Result-wrapped operations
-         */
-        this.milestones = {
-            /**
-             * List milestones for authenticated user
-             */
-            list: () => wrap(() => this.clients.milestones.get("/milestones")),
-            /**
-             * Get milestones by project ID
-             */
-            getByProject: (project_id) => wrap(() => this.clients.milestones.get(`/projects/${project_id}/milestones`)),
-            /**
-             * Get milestone by ID
-             */
-            find: (id) => wrap(async () => {
-                try {
-                    return await this.clients.milestones.get(`/milestones/${id}`);
-                }
-                catch (error) {
-                    return null;
-                }
-            }),
-            /**
-             * Create new milestone
-             */
-            create: (data) => wrap(() => this.clients.milestones.post("/milestones", { body: data })),
-            /**
-             * Update milestone
-             */
-            update: async (id, data) => wrap(async () => {
-                // Fetch the existing milestone to get required fields
-                const result = await this.milestones.find(id);
-                if (!result.ok)
-                    throw new Error(result.error.message);
-                if (!result.value)
-                    throw new Error(`Milestone with id ${id} not found`);
-                const milestone = result.value;
-                // Merge changes with existing milestone data
-                const updateData = {
-                    id: milestone.id,
-                    project_id: milestone.project_id,
-                    name: data.name ?? milestone.name,
-                    description: data.description ?? milestone.description,
-                    target_time: data.target_time ?? milestone.target_time,
-                    target_version: data.target_version ?? milestone.target_version,
-                };
-                return this.clients.milestones.patch(`/milestones/${id}`, { body: updateData });
-            }),
-            /**
-             * Delete milestone (soft delete)
-             */
-            delete: (id) => wrap(() => this.clients.milestones.delete(`/milestones/${id}`)),
-            /**
-             * Get goals for a milestone
-             */
-            goals: (id) => wrap(() => this.clients.milestones.get(`/milestones/${id}/goals`)),
-        };
-        /**
-         * Goals namespace with Result-wrapped operations
-         */
-        this.goals = {
-            /**
-             * List goals for authenticated user
-             */
-            list: () => wrap(() => this.clients.goals.get("/goals")),
-            /**
-             * Get goal by ID
-             */
-            find: (id) => wrap(() => this.clients.goals.get(`/goals/${id}`)),
-            /**
-             * Create new goal
-             */
-            create: (data) => wrap(() => this.clients.goals.post("/goals", { body: data })),
-            /**
-             * Update goal
-             */
-            update: async (id, data) => wrap(async () => {
-                // Fetch the existing goal to get required fields
-                const result = await this.goals.find(id);
-                if (!result.ok)
-                    throw new Error(result.error.message);
-                if (!result.value)
-                    throw new Error(`Goal with id ${id} not found`);
-                const goal = result.value;
-                // Merge changes with existing goal data
-                const updateData = {
-                    id: goal.id,
-                    milestone_id: goal.milestone_id,
-                    name: data.name ?? goal.name,
-                    description: data.description ?? goal.description,
-                    target_time: data.target_time ?? goal.target_time,
-                };
-                return this.clients.goals.patch(`/goals/${id}`, { body: updateData });
-            }),
-            /**
-             * Delete goal (soft delete)
-             */
-            delete: (id) => wrap(() => this.clients.goals.delete(`/goals/${id}`)),
-        };
-        /**
-         * Tasks namespace with Result-wrapped operations
-         */
-        this.tasks = {
-            /**
-             * List tasks with optional filtering
-             */
-            list: (filters) => wrap(() => {
-                const query = {};
-                if (filters?.project_id)
-                    query.project = filters.project_id;
-                if (filters?.tag_id)
-                    query.tag = filters.tag_id;
-                return this.clients.tasks.get("/tasks", Object.keys(query).length > 0 ? { query } : {});
-            }),
-            /**
-             * Get task by ID
-             */
-            find: (id) => wrap(() => this.clients.tasks.get("/tasks", { query: { id } })),
-            /**
-             * Get tasks by project ID
-             */
-            getByProject: (project_id) => wrap(() => this.clients.tasks.get(`/tasks`, { query: { project: project_id } })),
-            /**
-             * Create a new task
-             */
-            create: (data) => wrap(() => this.clients.tasks.patch("/tasks", { body: data })),
-            /**
-             * Update an existing task
-             */
-            update: async (id, changes) => wrap(async () => {
-                // Fetch existing task to merge changes
-                const result = await this.tasks.find(id);
-                if (!result.ok)
-                    throw new Error(result.error.message);
-                if (!result.value)
-                    throw new Error(`Task with id ${id} not found`);
-                const task = result.value;
-                const updateData = {
-                    id,
-                    title: task.task.title,
-                    summary: task.task.summary,
-                    description: task.task.description,
-                    progress: task.task.progress,
-                    visibility: task.task.visibility,
-                    start_time: task.task.start_time,
-                    end_time: task.task.end_time,
-                    priority: task.task.priority,
-                    owner_id: task.task.owner_id,
-                    project_id: task.task.project_id,
-                    ...changes,
-                };
-                return this.clients.tasks.patch("/tasks", { body: updateData });
-            }),
-            /**
-             * Upsert task (create or update)
-             */
-            upsert: (data) => wrap(() => this.clients.tasks.patch("/tasks", { body: data })),
-            /**
-             * Save tags for tasks
-             */
-            saveTags: (data) => wrap(() => this.clients.tasks.patch("/tasks/save_tags", { body: data })),
-            /**
-             * Delete task (soft delete)
-             */
-            deleteTask: (task) => wrap(() => this.clients.tasks.patch("/tasks", { body: { ...task.task, deleted: true } })),
-            /**
-             * Task history operations
-             */
-            history: {
-                /**
-                 * Get task history by task ID
-                 */
-                get: (task_id) => wrap(() => this.clients.tasks.get(`/tasks/history/${task_id}`)),
-            },
-        };
-        /**
-         * Tags namespace with Result-wrapped operations
-         */
-        this.tags = {
-            /**
-             * List tags for authenticated user
-             */
-            list: () => wrap(() => this.clients.tags.get("/tags")),
-        };
-        /**
-         * GitHub namespace with Result-wrapped operations
-         */
-        this.github = {
-            /**
-             * List repositories for authenticated user
-             */
-            repos: () => wrap(() => this.clients.github.get("/repos")),
-            /**
-             * List branches for a GitHub repository
-             */
-            branches: (owner, repo) => wrap(() => this.clients.github.get(`/repos/${owner}/${repo}/branches`)),
-        };
-        this.blog = {
-            posts: {
-                list: (params) => wrap(() => {
-                    const query = {};
-                    if (params?.category)
-                        query.category = params.category;
-                    if (params?.tag)
-                        query.tag = params.tag;
-                    if (params?.project)
-                        query.project = params.project;
-                    if (params?.status)
-                        query.status = params.status;
-                    if (params?.archived !== undefined)
-                        query.archived = String(params.archived);
-                    if (params?.limit)
-                        query.limit = String(params.limit);
-                    if (params?.offset !== undefined)
-                        query.offset = String(params.offset);
-                    if (params?.sort)
-                        query.sort = params.sort;
-                    return this.clients.blog.get("/blog/posts", Object.keys(query).length ? { query } : {});
-                }),
-                getBySlug: (slug) => wrap(() => this.clients.blog.get(`/blog/posts/${slug}`)),
-                create: (data) => wrap(() => this.clients.blog.post("/blog/posts", { body: data })),
-                update: (uuid, data) => wrap(() => this.clients.blog.put(`/blog/posts/${uuid}`, { body: data })),
-                delete: (uuid) => wrap(() => this.clients.blog.delete(`/blog/posts/${uuid}`)),
-                versions: (uuid) => wrap(() => this.clients.blog.get(`/blog/posts/${uuid}/versions`)),
-                version: (uuid, hash) => wrap(() => this.clients.blog.get(`/blog/posts/${uuid}/version/${hash}`)),
-                restore: (uuid, hash) => wrap(() => this.clients.blog.post(`/blog/posts/${uuid}/restore/${hash}`)),
-            },
-            tags: {
-                list: () => wrap(() => this.clients.blog.get("/blog/tags")),
-                getForPost: (uuid) => wrap(() => this.clients.blog.get(`/blog/tags/posts/${uuid}/tags`)),
-                setForPost: (uuid, tags) => wrap(() => this.clients.blog.put(`/blog/tags/posts/${uuid}/tags`, { body: { tags } })),
-                addToPost: (uuid, tags) => wrap(() => this.clients.blog.post(`/blog/tags/posts/${uuid}/tags`, { body: { tags } })),
-                removeFromPost: (uuid, tag) => wrap(() => this.clients.blog.delete(`/blog/tags/posts/${uuid}/tags/${tag}`)),
-            },
-            categories: {
-                tree: () => wrap(() => this.clients.blog.get("/blog/categories")),
-                create: (data) => wrap(() => this.clients.blog.post("/blog/categories", { body: data })),
-                update: (name, data) => wrap(() => this.clients.blog.put(`/blog/categories/${name}`, { body: data })),
-                delete: (name) => wrap(() => this.clients.blog.delete(`/blog/categories/${name}`)),
-            },
-            tokens: {
-                list: () => wrap(() => this.clients.blog.get("/blog/tokens")),
-                create: (data) => wrap(() => this.clients.blog.post("/blog/tokens", { body: data })),
-                update: (id, data) => wrap(() => this.clients.blog.put(`/blog/tokens/${id}`, { body: data })),
-                delete: (id) => wrap(() => this.clients.blog.delete(`/blog/tokens/${id}`)),
-            },
-        };
-        this.media = {
-            profiles: {
-                list: () => wrap(async () => {
-                    const res = await this.clients.media.get("/profiles");
-                    return res.profiles;
-                }),
-                create: (data) => wrap(() => this.clients.media.post("/profiles", { body: data })),
-                get: (id) => wrap(() => this.clients.media.get(`/profiles/${id}`)),
-                update: (id, data) => wrap(() => this.clients.media.patch(`/profiles/${id}`, { body: data })),
-                delete: (id) => wrap(() => this.clients.media.delete(`/profiles/${id}`)),
-                filters: {
-                    list: (profile_id) => wrap(async () => {
-                        const res = await this.clients.media.get(`/profiles/${profile_id}/filters`);
-                        return res.filters;
-                    }),
-                    add: (profile_id, data) => wrap(() => this.clients.media.post(`/profiles/${profile_id}/filters`, { body: data })),
-                    remove: (profile_id, filter_id) => wrap(() => this.clients.media.delete(`/profiles/${profile_id}/filters/${filter_id}`)),
-                },
-                timeline: (slug, params) => wrap(() => {
-                    const query = {};
-                    if (params?.limit)
-                        query.limit = String(params.limit);
-                    if (params?.before)
-                        query.before = params.before;
-                    return this.clients.media.get(`/profiles/${slug}/timeline`, Object.keys(query).length ? { query } : {});
-                }),
-            },
-            connections: {
-                list: (profile_id, options) => wrap(async () => {
-                    const query = { profile_id };
-                    if (options?.include_settings)
-                        query.include_settings = "true";
-                    const res = await this.clients.media.get("/connections", { query });
-                    return res.accounts;
-                }),
-                create: (data) => wrap(() => this.clients.media.post("/connections", { body: data })),
-                delete: (account_id) => wrap(() => this.clients.media.delete(`/connections/${account_id}`)),
-                refresh: (account_id) => wrap(() => this.clients.media.post(`/connections/${account_id}/refresh`)),
-                refreshAll: () => wrap(() => this.clients.media.post("/connections/refresh-all")),
-                updateStatus: (account_id, is_active) => wrap(() => this.clients.media.patch(`/connections/${account_id}`, { body: { is_active } })),
-                settings: {
-                    get: (account_id) => wrap(() => this.clients.media.get(`/connections/${account_id}/settings`)),
-                    update: (account_id, settings) => wrap(() => this.clients.media.put(`/connections/${account_id}/settings`, { body: { settings } })),
-                },
-                repos: (account_id) => wrap(async () => {
-                    const res = await this.clients.media.get(`/connections/${account_id}/repos`);
-                    return res.repos;
-                }),
-                subreddits: (account_id) => wrap(async () => {
-                    const res = await this.clients.media.get(`/connections/${account_id}/subreddits`);
-                    return res.subreddits;
-                }),
-            },
-            credentials: {
-                check: (platform, profile_id) => wrap(() => this.clients.media.get(`/credentials/${platform}`, { query: { profile_id } })),
-                save: (platform, data) => wrap(() => this.clients.media.post(`/credentials/${platform}`, { body: data })),
-                delete: (platform, profile_id) => wrap(() => this.clients.media.delete(`/credentials/${platform}`, { query: { profile_id } })),
-            },
-            timeline: {
-                get: (user_id, params) => wrap(() => {
-                    const query = {};
-                    if (params?.from)
-                        query.from = params.from;
-                    if (params?.to)
-                        query.to = params.to;
-                    return this.clients.media.get(`/timeline/${user_id}`, Object.keys(query).length ? { query } : {});
-                }),
-                getRaw: (user_id, platform, account_id) => wrap(() => this.clients.media.get(`/timeline/${user_id}/raw/${platform}`, { query: { account_id } })),
-            },
-        };
-        /**
-         * User namespace with Result-wrapped operations
-         */
-        this.user = {
-            /**
-             * Get user activity history
-             */
-            history: () => wrap(() => this.clients.auth.get("/user/history")),
-            /**
-             * Update user preferences
-             */
-            preferences: (data) => wrap(() => this.clients.auth.patch("/user/preferences", { body: data })),
-        };
-        const base_url = options.base_url || "http://localhost:4321/api/v1";
-        this._api_key = options.api_key ?? "";
-        this._auth_mode = options.auth_mode ?? (options.api_key?.startsWith("jwt:") ? "session" : options.api_key ? "key" : "cookie");
-        const clientOptions = {
-            base_url,
-            api_key: options.api_key,
-            max_history_size: options.max_history_size,
-            auth_mode: this._auth_mode,
-            credentials: options.credentials,
-            default_headers: options.default_headers,
-            custom_fetch: options.custom_fetch,
-        };
-        const auth_base_url = base_url.replace(/\/v1\/?$/, "");
-        this.clients = {
-            auth: new HttpClient({ ...clientOptions, category: "auth" }),
-            auth_root: new HttpClient({ ...clientOptions, base_url: auth_base_url, category: "auth" }),
-            projects: new HttpClient({ ...clientOptions, category: "projects" }),
-            tasks: new HttpClient({ ...clientOptions, category: "tasks" }),
-            milestones: new HttpClient({ ...clientOptions, category: "milestones" }),
-            goals: new HttpClient({ ...clientOptions, category: "goals" }),
-            github: new HttpClient({ ...clientOptions, category: "github" }),
-            tags: new HttpClient({ ...clientOptions, category: "tags" }),
-            blog: new HttpClient({ ...clientOptions, category: "blog" }),
-            media: new HttpClient({ ...clientOptions, category: "media" }),
-        };
-    }
-    /**
-     * Get request history for debugging
-     */
-    history() {
-        return this.clients.projects.history();
-    }
-    /**
-     * Get the API key
-     */
-    getApiKey() {
-        return this._api_key;
-    }
-    /**
-     * Get the authentication mode
-     */
-    getAuthMode() {
-        return this._auth_mode;
-    }
-}

package/dist/error-handlers.d.ts

@@ -1,55 +0,0 @@
-import { ApiError, AuthenticationError, NetworkError } from "./errors";
-/**
- * Centralized error handling utilities to reduce duplication
- * across API client methods and improve consistency
- */
-/**
- * Standard HTTP status codes
- */
-export declare const HTTP_STATUS: {
-    readonly OK: 200;
-    readonly CREATED: 201;
-    readonly NO_CONTENT: 204;
-    readonly BAD_REQUEST: 400;
-    readonly UNAUTHORIZED: 401;
-    readonly FORBIDDEN: 403;
-    readonly NOT_FOUND: 404;
-    readonly INTERNAL_SERVER_ERROR: 500;
-};
-/**
- * Handle response based on status code with consistent error types
- */
-export declare function handleHttpResponse(response: Response): void;
-/**
- * Parse and throw appropriate error from response text
- */
-export declare function handleResponseError(response: Response): Promise<never>;
-/**
- * Handle network errors consistently
- */
-export declare function handleNetworkError(error: unknown): never;
-/**
- * Type guard to check if error is an API error
- */
-export declare function isApiError(error: unknown): error is ApiError;
-/**
- * Type guard to check if error is an authentication error
- */
-export declare function isAuthenticationError(error: unknown): error is AuthenticationError;
-/**
- * Type guard to check if error is a network error
- */
-export declare function isNetworkError(error: unknown): error is NetworkError;
-/**
- * Parse Zod validation errors into user-friendly messages
- */
-export declare function parseZodErrors(errorMessage: string): string;
-/**
- * Get user-friendly error message from any error
- */
-export declare function getUserFriendlyErrorMessage(error: unknown): string;
-/**
- * Retry wrapper for API calls with exponential backoff
- */
-export declare function withRetry<T>(operation: () => Promise<T>, maxRetries?: number, baseDelay?: number): Promise<T>;
-//# sourceMappingURL=error-handlers.d.ts.map

package/dist/error-handlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-handlers.d.ts","sourceRoot":"","sources":["../src/error-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,YAAY,EAAmB,MAAM,UAAU,CAAC;AAExF;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;CASd,CAAC;AAEX;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAc3D;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,CAmB5E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAGxD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAElF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAgF3D;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CA0BlE;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,UAAU,GAAE,MAAU,EAAE,SAAS,GAAE,MAAa,GAAG,OAAO,CAAC,CAAC,CAAC,CA0B5H"}