@bardioc/app-sdk 0.4.0

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

@@ -0,0 +1,189 @@
+import type { Application, Configuration, CreateMemberInput, CreateUnitInput, FileEntry, InstanceList, OrgMember, OrgStructure, OrgUnit, OsRequestOptions, SdkTransportPayload, UpdateMemberInput, UpdateUnitInput, UserProfile } from '../types.js';
+/** 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

@@ -0,0 +1,444 @@
+import { EntityNotFoundError, NetworkError, PermissionError, SdkError, TimeoutError, ValidationError, } from '../errors.js';
+const OS_BASE = '/os';
+// Maps backend errors to typed SDK errors
+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 });
+        }
+    }
+}