@devpad/api 2.0.0 → 2.0.2

package/dist/index.d.ts

@@ -1,13 +1,541 @@
-import { ApiClient } from "./api-client";
-export type { Project, ProjectConfig, SaveConfigRequest, Task, TaskWithDetails, UpsertProject, UpsertTag, UpsertTodo, } from "@devpad/schema";
-export type { AccessKey, Category, CategoryCreate, Post, PostContent, PostCreate, PostListParams, PostsResponse, PostUpdate, VersionInfo, } from "@devpad/schema/blog";
-export type { Account, AddFilterInput, CreateProfileInput, PlatformSettings, Profile, ProfileFilter, Timeline, UpdateProfileInput, } from "@devpad/schema/media";
-export type { AuthMode } from "./api-client";
-export { getUserFriendlyErrorMessage, parseZodErrors } from "./error-handlers";
-export type { ApiError, AuthenticationError, NetworkError, ValidationError } from "./errors";
-export type { RequestHistoryEntry, RequestOptions } from "./request";
-export { type ApiResult, type ApiResultError, err, ok, type Result, wrap } from "./result";
-export { getTool, type ToolDefinition, toolNames, tools } from "./tools";
-export { ApiClient };
-export default ApiClient;
-//# sourceMappingURL=index.d.ts.map
+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-CoHRMrYJ.js';
+export { D as ProjectConfig, T as Task } from './types.d-CoHRMrYJ.js';
+import { S as PostListParams, a0 as PostsResponse, O as Post, Q as PostCreate, a2 as PostUpdate, V as VersionInfo, P as PostContent, C as Category, t as CategoryCreate, A as AccessKey } from './types.d-1hBObc_N.js';
+import { aC as Profile, C as CreateProfileInput, U as UpdateProfileInput, aD as ProfileFilter, A as AddFilterInput, Z as Timeline, ad as Account, H as PlatformSettings } from './types.d-UV8B6hPN.js';
+import { Result } from '@f0rbit/corpus';
+export { Result, err, ok } from '@f0rbit/corpus';
+import { z } from 'zod';
+import 'drizzle-orm';
+import './schema.d-BceDyQED.js';
+import 'drizzle-orm/sqlite-core';
+import './media.d-R87HGuRp.js';
+
+type RequestOptions = {
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    headers?: Record<string, string>;
+    body?: unknown;
+    query?: Record<string, string>;
+};
+type RequestHistoryEntry = {
+    timestamp: string;
+    method: string;
+    path: string;
+    options: RequestOptions;
+    url: string;
+    status?: number;
+    duration?: number;
+    error?: string;
+};
+
+type ApiResultError = {
+    message: string;
+    code?: string;
+    status_code?: number;
+};
+type ApiResult<T> = Result<T, ApiResultError>;
+declare function wrap<T>(fn: () => Promise<T>): Promise<ApiResult<T>>;
+
+type TagWithCount = {
+    tag: string;
+    count: number;
+};
+type SanitizedToken = {
+    id: string;
+    name: string | null;
+    note: string | null;
+    enabled: boolean;
+    created_at: string;
+};
+type CreatedToken = SanitizedToken & {
+    token: string;
+};
+type AccessKeyCreate = {
+    name: string;
+    note?: string;
+};
+type AccessKeyUpdate = {
+    name?: string;
+    note?: string;
+    enabled?: boolean;
+};
+/**
+ * Authentication mode for the API client
+ */
+type AuthMode = "session" | "key" | "cookie";
+/**
+ * API client with Result-wrapped operations for clean error handling
+ * All methods return ApiResult<T> types using @f0rbit/corpus Result
+ */
+declare class ApiClient {
+    private readonly clients;
+    private _api_key;
+    private _auth_mode;
+    constructor(options: {
+        base_url?: string;
+        api_key?: string;
+        auth_mode?: AuthMode;
+        max_history_size?: number;
+        credentials?: "include" | "omit" | "same-origin";
+        default_headers?: Record<string, string>;
+        custom_fetch?: typeof fetch;
+    });
+    /**
+     * Auth namespace with Result-wrapped operations
+     */
+    readonly auth: {
+        session: () => Promise<ApiResult<{
+            authenticated: boolean;
+            user: any;
+            session: any;
+        }>>;
+        keys: {
+            list: () => Promise<ApiResult<ApiKey[]>>;
+            create: (name?: string) => Promise<ApiResult<{
+                message: string;
+                key: string;
+            }>>;
+            revoke: (key_id: string) => Promise<ApiResult<{
+                message: string;
+                success: boolean;
+            }>>;
+            remove: (key_id: string) => Promise<ApiResult<{
+                message: string;
+                success: boolean;
+            }>>;
+        };
+    };
+    /**
+     * Projects namespace with Result-wrapped operations
+     */
+    readonly projects: {
+        /**
+         * List projects with optional filtering
+         */
+        list: (filters?: {
+            private?: boolean;
+        }) => Promise<ApiResult<Project[]>>;
+        /**
+         * Get project map
+         */
+        map: (filters?: {
+            private?: boolean;
+        }) => Promise<ApiResult<Record<string, Project>>>;
+        /**
+         * Get project by ID
+         */
+        find: (id: string) => Promise<ApiResult<Project | null>>;
+        /**
+         * Get project by name
+         */
+        getByName: (name: string) => Promise<ApiResult<Project>>;
+        /**
+         * Get project by ID (throws if not found)
+         */
+        getById: (id: string) => Promise<ApiResult<Project>>;
+        /**
+         * Create a new project
+         */
+        create: (data: Omit<UpsertProject, "id">) => Promise<ApiResult<Project>>;
+        /**
+         * Update an existing project
+         */
+        update: (idOrData: string | UpsertProject, changes?: Partial<Omit<UpsertProject, "id" | "project_id">>) => Promise<ApiResult<Project>>;
+        /**
+         * Project configuration operations
+         */
+        config: {
+            /**
+             * Get project configuration
+             */
+            load: (project_id: string) => Promise<ApiResult<GetConfigResult>>;
+            /**
+             * Save project configuration
+             */
+            save: (request: SaveConfigRequest) => Promise<ApiResult<void>>;
+        };
+        /**
+         * Scanning operations
+         */
+        scan: {
+            /**
+             * Initiate a repository scan (returns stream)
+             */
+            initiate: (project_id: string) => Promise<ReadableStream<string>>;
+            /**
+             * Get pending scan updates for a project
+             */
+            updates: (project_id: string) => Promise<ApiResult<any[]>>;
+            /**
+             * Process scan results
+             */
+            update: (project_id: string, data: any) => Promise<ApiResult<void>>;
+        };
+        /**
+         * Get project history
+         */
+        history: (project_id: string) => Promise<ApiResult<any[]>>;
+        /**
+         * Legacy methods (keeping for compatibility)
+         */
+        upsert: (data: UpsertProject) => Promise<ApiResult<Project>>;
+        /**
+         * Fetch project specification from GitHub
+         */
+        specification: (project_id: string) => Promise<ApiResult<string>>;
+        /**
+         * Delete project (soft delete)
+         */
+        deleteProject: (project: Project) => Promise<ApiResult<void>>;
+    };
+    /**
+     * Milestones namespace with Result-wrapped operations
+     */
+    readonly milestones: {
+        /**
+         * List milestones for authenticated user
+         */
+        list: () => Promise<ApiResult<Milestone[]>>;
+        /**
+         * Get milestones by project ID
+         */
+        getByProject: (project_id: string) => Promise<ApiResult<Milestone[]>>;
+        /**
+         * Get milestone by ID
+         */
+        find: (id: string) => Promise<ApiResult<Milestone | null>>;
+        /**
+         * Create new milestone
+         */
+        create: (data: {
+            project_id: string;
+            name: string;
+            description?: string;
+            target_time?: string;
+            target_version?: string;
+        }) => Promise<ApiResult<Milestone>>;
+        /**
+         * Update milestone
+         */
+        update: (id: string, data: {
+            name?: string;
+            description?: string;
+            target_time?: string;
+            target_version?: string;
+        }) => Promise<ApiResult<Milestone>>;
+        /**
+         * Delete milestone (soft delete)
+         */
+        delete: (id: string) => Promise<ApiResult<{
+            success: boolean;
+            message: string;
+        }>>;
+        /**
+         * Get goals for a milestone
+         */
+        goals: (id: string) => Promise<ApiResult<Goal[]>>;
+    };
+    /**
+     * Goals namespace with Result-wrapped operations
+     */
+    readonly goals: {
+        /**
+         * List goals for authenticated user
+         */
+        list: () => Promise<ApiResult<Goal[]>>;
+        /**
+         * Get goal by ID
+         */
+        find: (id: string) => Promise<ApiResult<Goal | null>>;
+        /**
+         * Create new goal
+         */
+        create: (data: {
+            milestone_id: string;
+            name: string;
+            description?: string;
+            target_time?: string;
+        }) => Promise<ApiResult<Goal>>;
+        /**
+         * Update goal
+         */
+        update: (id: string, data: {
+            name?: string;
+            description?: string;
+            target_time?: string;
+        }) => Promise<ApiResult<Goal>>;
+        /**
+         * Delete goal (soft delete)
+         */
+        delete: (id: string) => Promise<ApiResult<{
+            success: boolean;
+            message: string;
+        }>>;
+    };
+    /**
+     * Tasks namespace with Result-wrapped operations
+     */
+    readonly tasks: {
+        /**
+         * List tasks with optional filtering
+         */
+        list: (filters?: {
+            project_id?: string;
+            tag_id?: string;
+        }) => Promise<ApiResult<TaskWithDetails[]>>;
+        /**
+         * Get task by ID
+         */
+        find: (id: string) => Promise<ApiResult<TaskWithDetails | null>>;
+        /**
+         * Get tasks by project ID
+         */
+        getByProject: (project_id: string) => Promise<ApiResult<TaskWithDetails[]>>;
+        /**
+         * Create a new task
+         */
+        create: (data: Omit<UpsertTodo, "id"> & {
+            tags?: UpsertTag[];
+        }) => Promise<ApiResult<TaskWithDetails>>;
+        /**
+         * Update an existing task
+         */
+        update: (id: string, changes: Partial<Omit<UpsertTodo, "id">> & {
+            tags?: UpsertTag[];
+        }) => Promise<ApiResult<TaskWithDetails>>;
+        /**
+         * Upsert task (create or update)
+         */
+        upsert: (data: UpsertTodo & {
+            tags?: UpsertTag[];
+        }) => Promise<ApiResult<TaskWithDetails>>;
+        /**
+         * Save tags for tasks
+         */
+        saveTags: (data: any) => Promise<ApiResult<void>>;
+        /**
+         * Delete task (soft delete)
+         */
+        deleteTask: (task: TaskWithDetails) => Promise<ApiResult<void>>;
+        /**
+         * Task history operations
+         */
+        history: {
+            /**
+             * Get task history by task ID
+             */
+            get: (task_id: string) => Promise<ApiResult<HistoryAction[]>>;
+        };
+    };
+    /**
+     * Tags namespace with Result-wrapped operations
+     */
+    readonly tags: {
+        /**
+         * List tags for authenticated user
+         */
+        list: () => Promise<ApiResult<TagWithTypedColor[]>>;
+    };
+    /**
+     * GitHub namespace with Result-wrapped operations
+     */
+    readonly github: {
+        /**
+         * List repositories for authenticated user
+         */
+        repos: () => Promise<ApiResult<any[]>>;
+        /**
+         * List branches for a GitHub repository
+         */
+        branches: (owner: string, repo: string) => Promise<ApiResult<any[]>>;
+    };
+    readonly blog: {
+        posts: {
+            list: (params?: Partial<PostListParams>) => Promise<ApiResult<PostsResponse>>;
+            getBySlug: (slug: string) => Promise<ApiResult<Post>>;
+            create: (data: PostCreate) => Promise<ApiResult<Post>>;
+            update: (uuid: string, data: PostUpdate) => Promise<ApiResult<Post>>;
+            delete: (uuid: string) => Promise<ApiResult<{
+                success: boolean;
+            }>>;
+            versions: (uuid: string) => Promise<ApiResult<{
+                versions: VersionInfo[];
+            }>>;
+            version: (uuid: string, hash: string) => Promise<ApiResult<PostContent>>;
+            restore: (uuid: string, hash: string) => Promise<ApiResult<Post>>;
+        };
+        tags: {
+            list: () => Promise<ApiResult<{
+                tags: TagWithCount[];
+            }>>;
+            getForPost: (uuid: string) => Promise<ApiResult<{
+                tags: string[];
+            }>>;
+            setForPost: (uuid: string, tags: string[]) => Promise<ApiResult<{
+                tags: string[];
+            }>>;
+            addToPost: (uuid: string, tags: string[]) => Promise<ApiResult<{
+                tags: string[];
+            }>>;
+            removeFromPost: (uuid: string, tag: string) => Promise<ApiResult<void>>;
+        };
+        categories: {
+            tree: () => Promise<ApiResult<{
+                categories: Category[];
+            }>>;
+            create: (data: CategoryCreate) => Promise<ApiResult<Category>>;
+            update: (name: string, data: {
+                name: string;
+            }) => Promise<ApiResult<Category>>;
+            delete: (name: string) => Promise<ApiResult<void>>;
+        };
+        tokens: {
+            list: () => Promise<ApiResult<{
+                tokens: SanitizedToken[];
+            }>>;
+            create: (data: AccessKeyCreate) => Promise<ApiResult<CreatedToken>>;
+            update: (id: string, data: AccessKeyUpdate) => Promise<ApiResult<AccessKey>>;
+            delete: (id: string) => Promise<ApiResult<void>>;
+        };
+    };
+    readonly media: {
+        profiles: {
+            list: () => Promise<ApiResult<Profile[]>>;
+            create: (data: CreateProfileInput) => Promise<ApiResult<Profile>>;
+            get: (id: string) => Promise<ApiResult<Profile>>;
+            update: (id: string, data: UpdateProfileInput) => Promise<ApiResult<Profile>>;
+            delete: (id: string) => Promise<ApiResult<{
+                success: boolean;
+            }>>;
+            filters: {
+                list: (profile_id: string) => Promise<ApiResult<ProfileFilter[]>>;
+                add: (profile_id: string, data: AddFilterInput) => Promise<ApiResult<ProfileFilter>>;
+                remove: (profile_id: string, filter_id: string) => Promise<ApiResult<void>>;
+            };
+            timeline: (slug: string, params?: {
+                limit?: number;
+                before?: string;
+            }) => Promise<ApiResult<Timeline>>;
+        };
+        connections: {
+            list: (profile_id: string, options?: {
+                include_settings?: boolean;
+            }) => Promise<ApiResult<Account[]>>;
+            create: (data: {
+                profile_id: string;
+                platform: string;
+                access_token: string;
+                refresh_token?: string;
+                platform_user_id?: string;
+                platform_username?: string;
+                token_expires_at?: string;
+            }) => Promise<ApiResult<Account>>;
+            delete: (account_id: string) => Promise<ApiResult<{
+                success: boolean;
+            }>>;
+            refresh: (account_id: string) => Promise<ApiResult<any>>;
+            refreshAll: () => Promise<ApiResult<any>>;
+            updateStatus: (account_id: string, is_active: boolean) => Promise<ApiResult<Account>>;
+            settings: {
+                get: (account_id: string) => Promise<ApiResult<PlatformSettings>>;
+                update: (account_id: string, settings: Record<string, unknown>) => Promise<ApiResult<any>>;
+            };
+            repos: (account_id: string) => Promise<ApiResult<any[]>>;
+            subreddits: (account_id: string) => Promise<ApiResult<any[]>>;
+        };
+        credentials: {
+            check: (platform: string, profile_id: string) => Promise<ApiResult<{
+                exists: boolean;
+                isVerified: boolean;
+                clientId: string | null;
+            }>>;
+            save: (platform: string, data: {
+                profile_id: string;
+                client_id: string;
+                client_secret: string;
+                redirect_uri?: string;
+                reddit_username?: string;
+            }) => Promise<ApiResult<{
+                success: boolean;
+                id: string;
+            }>>;
+            delete: (platform: string, profile_id: string) => Promise<ApiResult<{
+                success: boolean;
+            }>>;
+        };
+        timeline: {
+            get: (user_id: string, params?: {
+                from?: string;
+                to?: string;
+            }) => Promise<ApiResult<Timeline>>;
+            getRaw: (user_id: string, platform: string, account_id: string) => Promise<ApiResult<any>>;
+        };
+    };
+    /**
+     * User namespace with Result-wrapped operations
+     */
+    readonly user: {
+        /**
+         * Get user activity history
+         */
+        history: () => Promise<ApiResult<any[]>>;
+        /**
+         * Update user preferences
+         */
+        preferences: (data: {
+            id: string;
+            task_view: string;
+        }) => Promise<ApiResult<any>>;
+    };
+    /**
+     * Get request history for debugging
+     */
+    history(): BufferedQueue<RequestHistoryEntry>;
+    /**
+     * Get the API key
+     */
+    getApiKey(): string;
+    /**
+     * Get the authentication mode
+     */
+    getAuthMode(): AuthMode;
+}
+
+declare class ApiError extends Error {
+    readonly code?: string;
+    readonly statusCode?: number;
+    constructor(message: string, options?: {
+        code?: string;
+        statusCode?: number;
+    });
+    static fromResponse(response: Response): ApiError;
+}
+declare class AuthenticationError extends ApiError {
+    constructor(message?: string);
+}
+declare class NetworkError extends ApiError {
+    constructor(message?: string);
+}
+declare class ValidationError extends ApiError {
+    constructor(message?: string);
+}
+
+/**
+ * Parse Zod validation errors into user-friendly messages
+ */
+declare function parseZodErrors(errorMessage: string): string;
+/**
+ * Get user-friendly error message from any error
+ */
+declare function getUserFriendlyErrorMessage(error: unknown): string;
+
+interface ToolDefinition<TInput = any, TOutput = any> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<TInput>;
+    execute: (client: ApiClient, input: TInput) => Promise<TOutput>;
+}
+declare const tools: Record<string, ToolDefinition>;
+declare const toolNames: string[];
+declare function getTool(name: string): ToolDefinition | undefined;
+
+export { AccessKey, Account, AddFilterInput, ApiClient, ApiError, type ApiResult, type ApiResultError, type AuthMode, AuthenticationError, Category, CategoryCreate, CreateProfileInput, NetworkError, PlatformSettings, Post, PostContent, PostCreate, PostListParams, PostUpdate, PostsResponse, Profile, ProfileFilter, Project, type RequestHistoryEntry, type RequestOptions, SaveConfigRequest, TaskWithDetails, Timeline, type ToolDefinition, UpdateProfileInput, UpsertProject, UpsertTag, UpsertTodo, ValidationError, VersionInfo, ApiClient as default, getTool, getUserFriendlyErrorMessage, parseZodErrors, toolNames, tools, wrap };