@hamak/ui-remote-resource-impl 0.4.19

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

@@ -0,0 +1,215 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockResourceProvider = void 0;
+/**
+ * Mock Resource Provider for testing
+ */
+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;
+    }
+    call(endpoint, params, operation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            // Invoke global callback
+            (_a = this.onAnyCall) === null || _a === void 0 ? void 0 : _a.call(this, endpoint, params, operation);
+            // Find matching mock config
+            const mockConfig = this.findMockConfig(endpoint);
+            // Determine delay
+            const delay = (_b = mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.delay) !== null && _b !== void 0 ? _b : this.defaultDelay;
+            // Simulate delay
+            if (delay > 0) {
+                yield 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 === null || mockConfig === void 0 ? void 0 : mockConfig.error) {
+                    throw this.createError(mockConfig.error);
+                }
+                // Invoke endpoint callback
+                (_c = mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.onCall) === null || _c === void 0 ? void 0 : _c.call(mockConfig, endpoint, params, operation);
+                // Generate response
+                const result = yield 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
+     */
+    generateResponse(endpoint, params, operation, mockConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Use custom response generator if provided
+            if (mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.responseGenerator) {
+                const result = yield mockConfig.responseGenerator(endpoint, params, operation);
+                return result;
+            }
+            // Use configured data
+            const data = (_a = mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.data) !== null && _a !== void 0 ? _a : this.defaultResponse;
+            const metadata = (_b = mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.metadata) !== null && _b !== void 0 ? _b : {
+                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 = {};
+    }
+}
+exports.MockResourceProvider = MockResourceProvider;

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

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestResourceProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+/**
+ * REST API resource provider using Axios
+ */
+class RestResourceProvider {
+    constructor(config = {}) {
+        this.type = 'rest';
+        this.axios =
+            config.axiosInstance ||
+                axios_1.default.create({
+                    baseURL: config.baseUrl,
+                    timeout: config.timeout || 30000,
+                    headers: Object.assign({ 'Content-Type': 'application/json' }, config.headers)
+                });
+    }
+    /**
+     * Execute a resource call
+     */
+    call(endpoint, params, operation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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)
+     */
+    executeFetch(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = this.buildUrl(endpoint, params.params);
+            const response = yield 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)
+     */
+    executeCreate(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield 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)
+     */
+    executeUpdate(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = this.buildUrl(endpoint, params.params);
+            const response = yield 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)
+     */
+    executeDelete(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = this.buildUrl(endpoint, params.params);
+            const response = yield 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;
+    }
+}
+exports.RestResourceProvider = RestResourceProvider;

package/dist/es2015/registry/entity-registry.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityRegistry = void 0;
+/**
+ * Entity registry implementation
+ * Manages entity definitions
+ */
+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);
+    }
+}
+exports.EntityRegistry = EntityRegistry;

package/dist/es2015/registry/resource-registry.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceRegistry = void 0;
+/**
+ * Resource registry implementation
+ * Manages resource endpoint definitions and providers
+ */
+class ResourceRegistry {
+    constructor() {
+        this.endpoints = new Map();
+        this.providers = new Map();
+    }
+    /**
+     * Register a resource endpoint
+     */
+    registerEndpoint(definition) {
+        if (this.endpoints.has(definition.id)) {
+            console.warn(`Resource endpoint "${definition.id}" is already registered. Overwriting.`);
+        }
+        this.endpoints.set(definition.id, definition);
+    }
+    /**
+     * Unregister a resource endpoint
+     */
+    unregisterEndpoint(id) {
+        this.endpoints.delete(id);
+    }
+    /**
+     * Get endpoint definition by ID
+     */
+    getEndpoint(id) {
+        return this.endpoints.get(id);
+    }
+    /**
+     * Get all registered endpoints
+     */
+    getAllEndpoints() {
+        return Array.from(this.endpoints.values());
+    }
+    /**
+     * Check if endpoint exists
+     */
+    hasEndpoint(id) {
+        return this.endpoints.has(id);
+    }
+    /**
+     * Register a resource provider
+     */
+    registerProvider(provider) {
+        if (this.providers.has(provider.type)) {
+            console.warn(`Resource provider "${provider.type}" is already registered. Overwriting.`);
+        }
+        this.providers.set(provider.type, provider);
+    }
+    /**
+     * Get provider by type
+     */
+    getProvider(type) {
+        return this.providers.get(type);
+    }
+    /**
+     * Get all registered providers
+     */
+    getAllProviders() {
+        return Array.from(this.providers.values());
+    }
+}
+exports.ResourceRegistry = ResourceRegistry;

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { createResourcePlugin } from './plugin/resource-plugin-factory';
+export type { PluginModule } from './plugin/resource-plugin-factory';
+export { RESOURCE_REGISTRY_TOKEN, ENTITY_REGISTRY_TOKEN } from './plugin/resource-plugin-factory';
+export { STORE_MANAGER_TOKEN, MIDDLEWARE_REGISTRY_TOKEN, STORE_EXTENSIONS_TOKEN } from '@hamak/ui-store-api';
+export { RestResourceProvider } from './providers/rest-resource-provider';
+export type { RestProviderConfig } from './providers/rest-resource-provider';
+export { MockResourceProvider } from './providers/mock-resource-provider';
+export type { MockProviderConfig, EndpointMockConfig, MockConfigMap, MockCallHistoryEntry } from './providers/mock-resource-provider';
+export { ResourceRegistry } from './registry/resource-registry';
+export { EntityRegistry } from './registry/entity-registry';
+export { createResourceMiddleware } from './middleware/resource-middleware';
+export { createSyncMiddleware } from './middleware/sync-middleware';
+export { createEntityMiddleware } from './middleware/entity-middleware';
+export { createEntitySyncMiddleware } from './middleware/entity-sync-middleware';
+export type { FileSystemNodeActions } from '@hamak/ui-store-impl';
+export type { ResourceOperation, EntityKey, ErrorObject, RemoteResourceAttributes, EntityAttributes } from '@hamak/ui-remote-resource-api';
+export type { IResourceProvider, ResourceCallParams, ResourceCallResult, ResourceEndpointDefinition, PayloadMapper, ResponseTransformer, EntityDefinition, EntityKeySchema, EntityKeyMapper, EntityPathGenerator, ResourcePluginConfig } from '@hamak/ui-remote-resource-spi';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,YAAY,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,YAAY,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,oBAAoB,EACrB,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAG5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAGjF,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGlE,YAAY,EACV,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,wBAAwB,EACxB,gBAAgB,EACjB,MAAM,+BAA+B,CAAC;AAGvC,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,0BAA0B,EAC1B,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,+BAA+B,CAAC"}

package/dist/index.js

@@ -0,0 +1,16 @@
+// Plugin factory (main export)
+export { createResourcePlugin } from './plugin/resource-plugin-factory';
+export { RESOURCE_REGISTRY_TOKEN, ENTITY_REGISTRY_TOKEN } from './plugin/resource-plugin-factory';
+// Re-export store tokens from ui-store-api for convenience
+export { STORE_MANAGER_TOKEN, MIDDLEWARE_REGISTRY_TOKEN, STORE_EXTENSIONS_TOKEN } from '@hamak/ui-store-api';
+// Built-in providers (exported for convenience and testing)
+export { RestResourceProvider } from './providers/rest-resource-provider';
+export { MockResourceProvider } from './providers/mock-resource-provider';
+// Registry implementations (internal, but exported for testing)
+export { ResourceRegistry } from './registry/resource-registry';
+export { EntityRegistry } from './registry/entity-registry';
+// Middleware factories (internal, but exported for advanced use cases)
+export { createResourceMiddleware } from './middleware/resource-middleware';
+export { createSyncMiddleware } from './middleware/sync-middleware';
+export { createEntityMiddleware } from './middleware/entity-middleware';
+export { createEntitySyncMiddleware } from './middleware/entity-sync-middleware';

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

@@ -0,0 +1,13 @@
+import type { Middleware } from 'redux';
+import { type EntityAction } from '@hamak/ui-remote-resource-api';
+export interface EntityMiddlewareConfig {
+    entityRegistry: any;
+    fsSliceName: string;
+    onError?: (error: any, action: EntityAction) => void;
+}
+/**
+ * Entity middleware
+ * Translates entity actions to resource actions
+ */
+export declare function createEntityMiddleware<S = any>(config: EntityMiddlewareConfig): Middleware<{}, S>;
+//# sourceMappingURL=entity-middleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entity-middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/entity-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,EAGL,KAAK,YAAY,EAMlB,MAAM,+BAA+B,CAAC;AAGvC,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,GAAG,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;CACtD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,GAAG,GAAG,EAC5C,MAAM,EAAE,sBAAsB,GAC7B,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CAgCnB"}