@bardioc/app-sdk 0.5.0 → 1.0.0

package/dist/transports/os-transport.d.ts

@@ -1,190 +0,0 @@
-import type { Application, Configuration, CreateMemberInput, CreateUnitInput, FileEntry, InstanceList, OrgMember, OrgStructure, OrgUnit, OsRequestOptions, SdkTransportPayload, UpdateMemberInput, UpdateUnitInput, UserProfile } from '../types.js';
-export declare function parseOsError(error: any, operation: string, context?: Record<string, unknown>): Error;
-/** OS transport class providing OS/system operations */
-export declare class OsTransport {
-    private readonly _request;
-    constructor(_request: <T = unknown>(payload: SdkTransportPayload) => Promise<T>);
-    /**
-     * User profile operations
-     */
-    profile: {
-        /**
-         * Get current user profile
-         *
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        get: () => Promise<UserProfile>;
-        /**
-         * Get user avatar image
-         *
-         * @throws {EntityNotFoundError} if avatar doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getAvatar: () => Promise<Blob>;
-        /**
-         * Upload user avatar
-         *
-         * @throws {ValidationError} if image format is invalid
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        setAvatar: (image: Blob) => Promise<void>;
-        /**
-         * Get accessible instances
-         *
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getInstances: () => Promise<InstanceList>;
-    };
-    /**
-     * Organization structure operations
-     */
-    organization: {
-        /**
-         * Get full organization hierarchy
-         *
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getStructure: () => Promise<OrgStructure>;
-        /**
-         * Create organizational unit
-         *
-         * @throws {ValidationError} if data is invalid or missing required fields
-         * @throws {PermissionError} if user lacks permission to create units
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        createUnit: (data: CreateUnitInput) => Promise<OrgUnit>;
-        /**
-         * Update organizational unit
-         *
-         * @throws {EntityNotFoundError} if unit doesn't exist
-         * @throws {ValidationError} if data is invalid
-         * @throws {PermissionError} if user lacks permission to update unit
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        updateUnit: (id: string, data: UpdateUnitInput) => Promise<OrgUnit>;
-        /**
-         * Create organization member
-         *
-         * @throws {ValidationError} if data is invalid or missing required fields
-         * @throws {PermissionError} if user lacks permission to create members
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        createMember: (data: CreateMemberInput) => Promise<OrgMember>;
-        /**
-         * Update organization member
-         *
-         * @throws {EntityNotFoundError} if member doesn't exist
-         * @throws {ValidationError} if data is invalid
-         * @throws {PermissionError} if user lacks permission to update member
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        updateMember: (id: string, data: UpdateMemberInput) => Promise<OrgMember>;
-        /**
-         * Delete organization member
-         *
-         * @throws {EntityNotFoundError} if member doesn't exist
-         * @throws {PermissionError} if user lacks permission to delete member
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        deleteMember: (id: string) => Promise<void>;
-        /**
-         * Send invitation email to member
-         *
-         * @throws {EntityNotFoundError} if member doesn't exist
-         * @throws {ValidationError} if member email is invalid
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        inviteMember: (id: string) => Promise<void>;
-    };
-    /**
-     * Application management
-     */
-    applications: {
-        /**
-         * List all applications
-         *
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        list: () => Promise<Application[]>;
-        /**
-         * Get application details
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        get: (appId: string) => Promise<Application>;
-        /**
-         * Upload application package (zip)
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {ValidationError} if file format is invalid
-         * @throws {PermissionError} if user lacks permission to upload
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        upload: (appId: string, zipFile: Blob) => Promise<void>;
-        /**
-         * Download application package
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {PermissionError} if user lacks permission to download
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        download: (appId: string) => Promise<Blob>;
-        /**
-         * List application files
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getFiles: (appId: string) => Promise<FileEntry[]>;
-        /**
-         * Get specific application file
-         *
-         * @throws {EntityNotFoundError} if application or file doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getFile: (appId: string, filePath: string) => Promise<string>;
-        /**
-         * List application configurations
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getConfigurations: (appId: string) => Promise<Configuration[]>;
-    };
-    /**
-     * Generic HTTP request for custom OS endpoints
-     *
-     * @example
-     * const data = await os.request<CustomResponse>({
-     *   path: '/custom/endpoint',
-     *   method: 'POST',
-     *   body: { foo: 'bar' }
-     * });
-     *
-     * @throws {EntityNotFoundError} on 404 errors
-     * @throws {ValidationError} on 400 errors
-     * @throws {PermissionError} on 403 errors
-     * @throws {NetworkError} on HTTP errors
-     * @throws {TimeoutError} on request timeout
-     */
-    request<T = unknown>(options: OsRequestOptions): Promise<T>;
-}

package/dist/transports/os-transport.js

@@ -1,444 +0,0 @@
-import { EntityNotFoundError, NetworkError, PermissionError, SdkError, TimeoutError, ValidationError, } from '../errors.js';
-const OS_BASE = '/os';
-// Maps backend errors to typed SDK errors
-export function parseOsError(error, operation, context) {
-    let statusCode;
-    let errorMessage = error.message || 'Unknown error';
-    if (error.responsePayload && typeof error.responsePayload === 'object') {
-        statusCode = error.responsePayload.status || error.responsePayload.statusCode;
-        if (error.responsePayload.message) {
-            errorMessage = error.responsePayload.message;
-        }
-    }
-    if (errorMessage.includes('timed out') || errorMessage.includes('timeout')) {
-        return new TimeoutError(operation, 10000);
-    }
-    if (statusCode) {
-        const fullContext = {
-            ...context,
-            operation,
-            timestamp: Date.now(),
-            statusCode,
-        };
-        switch (statusCode) {
-            case 404:
-                return new EntityNotFoundError(context?.id || context?.appId || 'unknown');
-            case 400:
-                return new ValidationError(errorMessage, context?.field);
-            case 403:
-                return new PermissionError(errorMessage);
-            case 408:
-                return new TimeoutError(operation, 10000);
-            case 500:
-            case 502:
-            case 503:
-                return new NetworkError(errorMessage, statusCode);
-            default:
-                if (statusCode >= 400) {
-                    return new NetworkError(errorMessage, statusCode);
-                }
-        }
-    }
-    return new SdkError(errorMessage, 'UNKNOWN_ERROR', statusCode, {
-        ...context,
-        operation,
-        timestamp: Date.now(),
-    });
-}
-/** OS transport class providing OS/system operations */
-export class OsTransport {
-    _request;
-    constructor(_request) {
-        this._request = _request;
-    }
-    /**
-     * User profile operations
-     */
-    profile = {
-        /**
-         * Get current user profile
-         *
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        get: async () => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/me/profile`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.profile.get');
-            }
-        },
-        /**
-         * Get user avatar image
-         *
-         * @throws {EntityNotFoundError} if avatar doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getAvatar: async () => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/me/avatar`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.profile.getAvatar');
-            }
-        },
-        /**
-         * Upload user avatar
-         *
-         * @throws {ValidationError} if image format is invalid
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        setAvatar: async (image) => {
-            try {
-                await this._request({
-                    path: `${OS_BASE}/me/avatar`,
-                    method: 'POST',
-                    body: image,
-                    contentType: 'application/octet-stream',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.profile.setAvatar');
-            }
-        },
-        /**
-         * Get accessible instances
-         *
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getInstances: async () => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/me/instances`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.profile.getInstances');
-            }
-        },
-    };
-    /**
-     * Organization structure operations
-     */
-    organization = {
-        /**
-         * Get full organization hierarchy
-         *
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getStructure: async () => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/organization/structure`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.organization.getStructure');
-            }
-        },
-        /**
-         * Create organizational unit
-         *
-         * @throws {ValidationError} if data is invalid or missing required fields
-         * @throws {PermissionError} if user lacks permission to create units
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        createUnit: async (data) => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/organization/units`,
-                    method: 'POST',
-                    body: data,
-                    contentType: 'application/json',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.organization.createUnit', { name: data.name });
-            }
-        },
-        /**
-         * Update organizational unit
-         *
-         * @throws {EntityNotFoundError} if unit doesn't exist
-         * @throws {ValidationError} if data is invalid
-         * @throws {PermissionError} if user lacks permission to update unit
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        updateUnit: async (id, data) => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/organization/units/${encodeURIComponent(id)}`,
-                    method: 'PATCH',
-                    body: data,
-                    contentType: 'application/json',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.organization.updateUnit', { id });
-            }
-        },
-        /**
-         * Create organization member
-         *
-         * @throws {ValidationError} if data is invalid or missing required fields
-         * @throws {PermissionError} if user lacks permission to create members
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        createMember: async (data) => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/organization/members`,
-                    method: 'POST',
-                    body: data,
-                    contentType: 'application/json',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.organization.createMember', { email: data.mailAddress });
-            }
-        },
-        /**
-         * Update organization member
-         *
-         * @throws {EntityNotFoundError} if member doesn't exist
-         * @throws {ValidationError} if data is invalid
-         * @throws {PermissionError} if user lacks permission to update member
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        updateMember: async (id, data) => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/organization/members/${encodeURIComponent(id)}`,
-                    method: 'PATCH',
-                    body: data,
-                    contentType: 'application/json',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.organization.updateMember', { id });
-            }
-        },
-        /**
-         * Delete organization member
-         *
-         * @throws {EntityNotFoundError} if member doesn't exist
-         * @throws {PermissionError} if user lacks permission to delete member
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        deleteMember: async (id) => {
-            try {
-                await this._request({
-                    path: `${OS_BASE}/organization/members/${encodeURIComponent(id)}`,
-                    method: 'DELETE',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.organization.deleteMember', { id });
-            }
-        },
-        /**
-         * Send invitation email to member
-         *
-         * @throws {EntityNotFoundError} if member doesn't exist
-         * @throws {ValidationError} if member email is invalid
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        inviteMember: async (id) => {
-            try {
-                await this._request({
-                    path: `${OS_BASE}/organization/members/${encodeURIComponent(id)}/invite`,
-                    method: 'POST',
-                    contentType: 'application/json',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.organization.inviteMember', { id });
-            }
-        },
-    };
-    /**
-     * Application management
-     */
-    applications = {
-        /**
-         * List all applications
-         *
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        list: async () => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/applications`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.applications.list');
-            }
-        },
-        /**
-         * Get application details
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        get: async (appId) => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.applications.get', { appId });
-            }
-        },
-        /**
-         * Upload application package (zip)
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {ValidationError} if file format is invalid
-         * @throws {PermissionError} if user lacks permission to upload
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        upload: async (appId, zipFile) => {
-            try {
-                await this._request({
-                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/upload`,
-                    method: 'POST',
-                    body: zipFile,
-                    contentType: 'application/zip',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.applications.upload', { appId });
-            }
-        },
-        /**
-         * Download application package
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {PermissionError} if user lacks permission to download
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        download: async (appId) => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/download`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.applications.download', { appId });
-            }
-        },
-        /**
-         * List application files
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getFiles: async (appId) => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/files`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.applications.getFiles', { appId });
-            }
-        },
-        /**
-         * Get specific application file
-         *
-         * @throws {EntityNotFoundError} if application or file doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getFile: async (appId, filePath) => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/files/${encodeURIComponent(filePath)}`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.applications.getFile', { appId, filePath });
-            }
-        },
-        /**
-         * List application configurations
-         *
-         * @throws {EntityNotFoundError} if application doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        getConfigurations: async (appId) => {
-            try {
-                return await this._request({
-                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/configurations`,
-                    method: 'GET',
-                });
-            }
-            catch (error) {
-                throw parseOsError(error, 'os.applications.getConfigurations', { appId });
-            }
-        },
-    };
-    /**
-     * Generic HTTP request for custom OS endpoints
-     *
-     * @example
-     * const data = await os.request<CustomResponse>({
-     *   path: '/custom/endpoint',
-     *   method: 'POST',
-     *   body: { foo: 'bar' }
-     * });
-     *
-     * @throws {EntityNotFoundError} on 404 errors
-     * @throws {ValidationError} on 400 errors
-     * @throws {PermissionError} on 403 errors
-     * @throws {NetworkError} on HTTP errors
-     * @throws {TimeoutError} on request timeout
-     */
-    async request(options) {
-        try {
-            return await this._request({
-                path: `${OS_BASE}${options.path}`,
-                method: options.method || 'GET',
-                body: options.body,
-                contentType: options.contentType,
-                scopeId: options.scopeId,
-                scopePolicy: options.scopePolicy,
-            });
-        }
-        catch (error) {
-            throw parseOsError(error, 'os.request', { path: options.path, method: options.method });
-        }
-    }
-}