@hamak/ui-remote-resource-impl 0.4.19

package/dist/providers/mock-resource-provider.d.ts

@@ -0,0 +1,147 @@
+import type { IResourceProvider, ResourceCallParams, ResourceCallResult } from '@hamak/ui-remote-resource-spi';
+import type { ResourceOperation } from '@hamak/ui-remote-resource-api';
+/**
+ * Configuration for a single endpoint mock
+ */
+export interface EndpointMockConfig {
+    /** Mock response data */
+    data?: any;
+    /** Mock metadata */
+    metadata?: any;
+    /** Simulate delay in ms */
+    delay?: number;
+    /** Simulate error */
+    error?: {
+        message: string;
+        code?: string;
+        details?: any;
+    };
+    /** Dynamic response generator */
+    responseGenerator?: (endpoint: string, params: ResourceCallParams, operation: ResourceOperation) => Promise<ResourceCallResult> | ResourceCallResult;
+    /** Callback invoked when this endpoint is called */
+    onCall?: (endpoint: string, params: ResourceCallParams, operation: ResourceOperation) => void;
+}
+/**
+ * Mock configuration map: endpoint pattern -> config
+ */
+export type MockConfigMap = Record<string, EndpointMockConfig>;
+/**
+ * Call history entry
+ */
+export interface MockCallHistoryEntry {
+    timestamp: number;
+    endpoint: string;
+    params: ResourceCallParams;
+    operation: ResourceOperation;
+    result?: ResourceCallResult;
+    error?: any;
+}
+/**
+ * Mock provider configuration
+ */
+export interface MockProviderConfig {
+    /** Predefined mocks for specific endpoints */
+    mocks?: MockConfigMap;
+    /** Default delay for all calls (can be overridden per endpoint) */
+    defaultDelay?: number;
+    /** Default response for unmocked endpoints */
+    defaultResponse?: any;
+    /** Whether to track call history */
+    trackHistory?: boolean;
+    /** Global error to simulate (overrides all endpoint configs) */
+    globalError?: {
+        message: string;
+        code?: string;
+        details?: any;
+    };
+    /** Callback for all calls */
+    onAnyCall?: (endpoint: string, params: ResourceCallParams, operation: ResourceOperation) => void;
+}
+/**
+ * Mock Resource Provider for testing
+ */
+export declare class MockResourceProvider implements IResourceProvider {
+    readonly type = "mock";
+    private mocks;
+    private defaultDelay;
+    private defaultResponse;
+    private trackHistory;
+    private globalError?;
+    private onAnyCall?;
+    private callHistory;
+    constructor(config?: MockProviderConfig);
+    call<TData = any>(endpoint: string, params: ResourceCallParams, operation: ResourceOperation): Promise<ResourceCallResult<TData>>;
+    /**
+     * Find mock config for endpoint (supports pattern matching)
+     */
+    private findMockConfig;
+    /**
+     * Simple pattern matching for endpoints
+     */
+    private matchesPattern;
+    /**
+     * Generate response based on config
+     */
+    private generateResponse;
+    /**
+     * Create error object
+     */
+    private createError;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+    /**
+     * Get call history
+     */
+    getCallHistory(): MockCallHistoryEntry[];
+    /**
+     * Get calls for specific endpoint
+     */
+    getCallsForEndpoint(endpoint: string): MockCallHistoryEntry[];
+    /**
+     * Get calls for specific operation
+     */
+    getCallsForOperation(operation: ResourceOperation): MockCallHistoryEntry[];
+    /**
+     * Clear call history
+     */
+    clearHistory(): void;
+    /**
+     * Get last call
+     */
+    getLastCall(): MockCallHistoryEntry | undefined;
+    /**
+     * Check if endpoint was called
+     */
+    wasEndpointCalled(endpoint: string, operation?: ResourceOperation): boolean;
+    /**
+     * Get call count for endpoint
+     */
+    getCallCount(endpoint?: string, operation?: ResourceOperation): number;
+    /**
+     * Add or update mock configuration
+     */
+    setMock(endpoint: string, config: EndpointMockConfig): void;
+    /**
+     * Remove mock configuration
+     */
+    removeMock(endpoint: string): void;
+    /**
+     * Set global error (all calls will fail)
+     */
+    setGlobalError(error?: {
+        message: string;
+        code?: string;
+        details?: any;
+    }): void;
+    /**
+     * Clear global error
+     */
+    clearGlobalError(): void;
+    /**
+     * Reset provider to initial state
+     */
+    reset(): void;
+}
+//# sourceMappingURL=mock-resource-provider.d.ts.map

package/dist/providers/mock-resource-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-resource-provider.d.ts","sourceRoot":"","sources":["../../src/providers/mock-resource-provider.ts"],"names":[],"mappings":"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"}

package/dist/providers/mock-resource-provider.js

@@ -0,0 +1,196 @@
+/**
+ * Mock Resource Provider for testing
+ */
+export class MockResourceProvider {
+    constructor(config = {}) {
+        this.type = 'mock';
+        this.callHistory = [];
+        this.mocks = config.mocks || {};
+        this.defaultDelay = config.defaultDelay || 0;
+        this.defaultResponse = config.defaultResponse || { message: 'Mock response' };
+        this.trackHistory = config.trackHistory !== false; // Default true
+        this.globalError = config.globalError;
+        this.onAnyCall = config.onAnyCall;
+    }
+    async call(endpoint, params, operation) {
+        // Invoke global callback
+        this.onAnyCall?.(endpoint, params, operation);
+        // Find matching mock config
+        const mockConfig = this.findMockConfig(endpoint);
+        // Determine delay
+        const delay = mockConfig?.delay ?? this.defaultDelay;
+        // Simulate delay
+        if (delay > 0) {
+            await this.sleep(delay);
+        }
+        // Record call start
+        const historyEntry = {
+            timestamp: Date.now(),
+            endpoint,
+            params,
+            operation
+        };
+        try {
+            // Check for global error
+            if (this.globalError) {
+                throw this.createError(this.globalError);
+            }
+            // Check for endpoint-specific error
+            if (mockConfig?.error) {
+                throw this.createError(mockConfig.error);
+            }
+            // Invoke endpoint callback
+            mockConfig?.onCall?.(endpoint, params, operation);
+            // Generate response
+            const result = await this.generateResponse(endpoint, params, operation, mockConfig);
+            // Record success
+            if (this.trackHistory) {
+                historyEntry.result = result;
+                this.callHistory.push(historyEntry);
+            }
+            return result;
+        }
+        catch (error) {
+            // Record error
+            if (this.trackHistory) {
+                historyEntry.error = error;
+                this.callHistory.push(historyEntry);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Find mock config for endpoint (supports pattern matching)
+     */
+    findMockConfig(endpoint) {
+        // Exact match
+        if (this.mocks[endpoint]) {
+            return this.mocks[endpoint];
+        }
+        // Pattern matching (e.g., "/api/users/:id" matches "/api/users/123")
+        for (const [pattern, config] of Object.entries(this.mocks)) {
+            if (this.matchesPattern(endpoint, pattern)) {
+                return config;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Simple pattern matching for endpoints
+     */
+    matchesPattern(endpoint, pattern) {
+        const patternRegex = pattern.replace(/:[^/]+/g, '[^/]+');
+        const regex = new RegExp(`^${patternRegex}$`);
+        return regex.test(endpoint);
+    }
+    /**
+     * Generate response based on config
+     */
+    async generateResponse(endpoint, params, operation, mockConfig) {
+        // Use custom response generator if provided
+        if (mockConfig?.responseGenerator) {
+            const result = await mockConfig.responseGenerator(endpoint, params, operation);
+            return result;
+        }
+        // Use configured data
+        const data = mockConfig?.data ?? this.defaultResponse;
+        const metadata = mockConfig?.metadata ?? {
+            status: 200,
+            headers: { 'content-type': 'application/json' }
+        };
+        return { data, metadata };
+    }
+    /**
+     * Create error object
+     */
+    createError(errorConfig) {
+        const error = new Error(errorConfig.message);
+        error.code = errorConfig.code;
+        error.details = errorConfig.details;
+        return error;
+    }
+    /**
+     * Sleep helper
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // ========== Testing Utilities ==========
+    /**
+     * Get call history
+     */
+    getCallHistory() {
+        return [...this.callHistory];
+    }
+    /**
+     * Get calls for specific endpoint
+     */
+    getCallsForEndpoint(endpoint) {
+        return this.callHistory.filter((entry) => entry.endpoint === endpoint);
+    }
+    /**
+     * Get calls for specific operation
+     */
+    getCallsForOperation(operation) {
+        return this.callHistory.filter((entry) => entry.operation === operation);
+    }
+    /**
+     * Clear call history
+     */
+    clearHistory() {
+        this.callHistory = [];
+    }
+    /**
+     * Get last call
+     */
+    getLastCall() {
+        return this.callHistory[this.callHistory.length - 1];
+    }
+    /**
+     * Check if endpoint was called
+     */
+    wasEndpointCalled(endpoint, operation) {
+        return this.callHistory.some((entry) => entry.endpoint === endpoint && (!operation || entry.operation === operation));
+    }
+    /**
+     * Get call count for endpoint
+     */
+    getCallCount(endpoint, operation) {
+        if (!endpoint) {
+            return this.callHistory.length;
+        }
+        return this.callHistory.filter((entry) => entry.endpoint === endpoint && (!operation || entry.operation === operation)).length;
+    }
+    /**
+     * Add or update mock configuration
+     */
+    setMock(endpoint, config) {
+        this.mocks[endpoint] = config;
+    }
+    /**
+     * Remove mock configuration
+     */
+    removeMock(endpoint) {
+        delete this.mocks[endpoint];
+    }
+    /**
+     * Set global error (all calls will fail)
+     */
+    setGlobalError(error) {
+        this.globalError = error;
+    }
+    /**
+     * Clear global error
+     */
+    clearGlobalError() {
+        this.globalError = undefined;
+    }
+    /**
+     * Reset provider to initial state
+     */
+    reset() {
+        this.clearHistory();
+        this.clearGlobalError();
+        this.mocks = {};
+    }
+}

package/dist/providers/rest-resource-provider.d.ts

@@ -0,0 +1,51 @@
+import { type AxiosInstance } from 'axios';
+import type { IResourceProvider, ResourceCallParams, ResourceCallResult } from '@hamak/ui-remote-resource-spi';
+import type { ResourceOperation } from '@hamak/ui-remote-resource-api';
+/**
+ * Configuration for REST resource provider
+ */
+export interface RestProviderConfig {
+    /** Base URL for API requests */
+    baseUrl?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Default headers for all requests */
+    headers?: Record<string, string>;
+    /** Custom axios instance (if not provided, one will be created) */
+    axiosInstance?: AxiosInstance;
+}
+/**
+ * REST API resource provider using Axios
+ */
+export declare class RestResourceProvider implements IResourceProvider {
+    readonly type = "rest";
+    private axios;
+    constructor(config?: RestProviderConfig);
+    /**
+     * Execute a resource call
+     */
+    call<TData = any>(endpoint: string, params: ResourceCallParams, operation: ResourceOperation): Promise<ResourceCallResult<TData>>;
+    /**
+     * Execute fetch operation (GET)
+     */
+    private executeFetch;
+    /**
+     * Execute create operation (POST)
+     */
+    private executeCreate;
+    /**
+     * Execute update operation (PUT)
+     */
+    private executeUpdate;
+    /**
+     * Execute delete operation (DELETE)
+     */
+    private executeDelete;
+    /**
+     * Build URL with path parameters
+     * Replaces :param placeholders with actual values
+     * Example: /users/:id + { id: "123" } → /users/123
+     */
+    private buildUrl;
+}
+//# sourceMappingURL=rest-resource-provider.d.ts.map

package/dist/providers/rest-resource-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest-resource-provider.d.ts","sourceRoot":"","sources":["../../src/providers/rest-resource-provider.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,gCAAgC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC,mEAAmE;IACnE,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;GAEG;AACH,qBAAa,oBAAqB,YAAW,iBAAiB;IAC5D,QAAQ,CAAC,IAAI,UAAU;IACvB,OAAO,CAAC,KAAK,CAAgB;gBAEjB,MAAM,GAAE,kBAAuB;IAa3C;;OAEG;IACG,IAAI,CAAC,KAAK,GAAG,GAAG,EACpB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,EAC1B,SAAS,EAAE,iBAAiB,GAC3B,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAerC;;OAEG;YACW,YAAY;IAmB1B;;OAEG;YACW,aAAa;IAkB3B;;OAEG;YACW,aAAa;IAmB3B;;OAEG;YACW,aAAa;IAmB3B;;;;OAIG;IACH,OAAO,CAAC,QAAQ;CAUjB"}

package/dist/providers/rest-resource-provider.js

@@ -0,0 +1,117 @@
+import axios from 'axios';
+/**
+ * REST API resource provider using Axios
+ */
+export class RestResourceProvider {
+    constructor(config = {}) {
+        this.type = 'rest';
+        this.axios =
+            config.axiosInstance ||
+                axios.create({
+                    baseURL: config.baseUrl,
+                    timeout: config.timeout || 30000,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...config.headers
+                    }
+                });
+    }
+    /**
+     * Execute a resource call
+     */
+    async call(endpoint, params, operation) {
+        switch (operation) {
+            case 'fetch':
+                return this.executeFetch(endpoint, params);
+            case 'create':
+                return this.executeCreate(endpoint, params);
+            case 'update':
+                return this.executeUpdate(endpoint, params);
+            case 'delete':
+                return this.executeDelete(endpoint, params);
+            default:
+                throw new Error(`Unknown operation: ${operation}`);
+        }
+    }
+    /**
+     * Execute fetch operation (GET)
+     */
+    async executeFetch(endpoint, params) {
+        const url = this.buildUrl(endpoint, params.params);
+        const response = await this.axios.get(url, {
+            params: params.query,
+            headers: params.headers
+        });
+        return {
+            data: response.data,
+            metadata: {
+                status: response.status,
+                headers: response.headers
+            }
+        };
+    }
+    /**
+     * Execute create operation (POST)
+     */
+    async executeCreate(endpoint, params) {
+        const response = await this.axios.post(endpoint, params.body, {
+            params: params.query,
+            headers: params.headers
+        });
+        return {
+            data: response.data,
+            metadata: {
+                status: response.status,
+                headers: response.headers
+            }
+        };
+    }
+    /**
+     * Execute update operation (PUT)
+     */
+    async executeUpdate(endpoint, params) {
+        const url = this.buildUrl(endpoint, params.params);
+        const response = await this.axios.put(url, params.body, {
+            params: params.query,
+            headers: params.headers
+        });
+        return {
+            data: response.data,
+            metadata: {
+                status: response.status,
+                headers: response.headers
+            }
+        };
+    }
+    /**
+     * Execute delete operation (DELETE)
+     */
+    async executeDelete(endpoint, params) {
+        const url = this.buildUrl(endpoint, params.params);
+        const response = await this.axios.delete(url, {
+            params: params.query,
+            headers: params.headers
+        });
+        return {
+            data: response.data,
+            metadata: {
+                status: response.status,
+                headers: response.headers
+            }
+        };
+    }
+    /**
+     * Build URL with path parameters
+     * Replaces :param placeholders with actual values
+     * Example: /users/:id + { id: "123" } → /users/123
+     */
+    buildUrl(endpoint, params) {
+        if (!params)
+            return endpoint;
+        let url = endpoint;
+        Object.entries(params).forEach(([key, value]) => {
+            url = url.replace(`:${key}`, String(value));
+        });
+        return url;
+    }
+}

package/dist/registry/entity-registry.d.ts

@@ -0,0 +1,54 @@
+import type { EntityDefinition } from '@hamak/ui-remote-resource-spi';
+/**
+ * Internal entity registry interface with write operations
+ */
+export interface IEntityRegistryInternal {
+    /**
+     * Register an entity definition
+     */
+    registerEntity(definition: EntityDefinition): void;
+    /**
+     * Unregister an entity definition
+     */
+    unregisterEntity(id: string): void;
+    /**
+     * Get entity definition by ID
+     */
+    getEntity(id: string): EntityDefinition | undefined;
+    /**
+     * Get all registered entities
+     */
+    getAllEntities(): EntityDefinition[];
+    /**
+     * Check if entity exists
+     */
+    hasEntity(id: string): boolean;
+}
+/**
+ * Entity registry implementation
+ * Manages entity definitions
+ */
+export declare class EntityRegistry implements IEntityRegistryInternal {
+    private entities;
+    /**
+     * Register an entity definition
+     */
+    registerEntity(definition: EntityDefinition): void;
+    /**
+     * Unregister an entity definition
+     */
+    unregisterEntity(id: string): void;
+    /**
+     * Get entity definition by ID
+     */
+    getEntity(id: string): EntityDefinition | undefined;
+    /**
+     * Get all registered entities
+     */
+    getAllEntities(): EntityDefinition[];
+    /**
+     * Check if entity exists
+     */
+    hasEntity(id: string): boolean;
+}
+//# sourceMappingURL=entity-registry.d.ts.map

package/dist/registry/entity-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-registry.d.ts","sourceRoot":"","sources":["../../src/registry/entity-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,cAAc,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAEnD;;OAEG;IACH,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAEnC;;OAEG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAEpD;;OAEG;IACH,cAAc,IAAI,gBAAgB,EAAE,CAAC;IAErC;;OAEG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC;AAED;;;GAGG;AACH,qBAAa,cAAe,YAAW,uBAAuB;IAC5D,OAAO,CAAC,QAAQ,CAA4C;IAE5D;;OAEG;IACH,cAAc,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAiBlD;;OAEG;IACH,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIlC;;OAEG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAInD;;OAEG;IACH,cAAc,IAAI,gBAAgB,EAAE;IAIpC;;OAEG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;CAG/B"}

package/dist/registry/entity-registry.js

@@ -0,0 +1,46 @@
+/**
+ * Entity registry implementation
+ * Manages entity definitions
+ */
+export class EntityRegistry {
+    constructor() {
+        this.entities = new Map();
+    }
+    /**
+     * Register an entity definition
+     */
+    registerEntity(definition) {
+        // Validate key schema
+        if (!definition.keySchema.fields || definition.keySchema.fields.length === 0) {
+            throw new Error(`Entity "${definition.id}" must have at least one key field in keySchema.fields`);
+        }
+        if (this.entities.has(definition.id)) {
+            console.warn(`Entity "${definition.id}" is already registered. Overwriting.`);
+        }
+        this.entities.set(definition.id, definition);
+    }
+    /**
+     * Unregister an entity definition
+     */
+    unregisterEntity(id) {
+        this.entities.delete(id);
+    }
+    /**
+     * Get entity definition by ID
+     */
+    getEntity(id) {
+        return this.entities.get(id);
+    }
+    /**
+     * Get all registered entities
+     */
+    getAllEntities() {
+        return Array.from(this.entities.values());
+    }
+    /**
+     * Check if entity exists
+     */
+    hasEntity(id) {
+        return this.entities.has(id);
+    }
+}