@creact-labs/creact 0.1.7 → 0.2.0

package/dist/providers/DummyBackendProvider.d.ts

@@ -1,193 +0,0 @@
-/**
-
- * Licensed under the Apache License, Version 2.0 (the "License");
-
- * you may not use this file except in compliance with the License.
-
- * You may obtain a copy of the License at
-
- *
-
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- *
-
- * Unless required by applicable law or agreed to in writing, software
-
- * distributed under the License is distributed on an "AS IS" BASIS,
-
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
- * See the License for the specific language governing permissions and
-
- * limitations under the License.
-
- *
-
- * Copyright 2025 Daniel Coutinho Ribeiro
-
- */
-
-/**
-
- * Licensed under the Apache License, Version 2.0 (the "License");
-
- * you may not use this file except in compliance with the License.
-
- * You may obtain a copy of the License at
-
- *
-
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- *
-
- * Unless required by applicable law or agreed to in writing, software
-
- * distributed under the License is distributed on an "AS IS" BASIS,
-
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
- * See the License for the specific language governing permissions and
-
- * limitations under the License.
-
- *
-
- * Copyright 2025 Daniel Coutinho Ribeiro
-
- */
-
-import { IBackendProvider } from './IBackendProvider';
-/**
- * DummyBackendProvider is a POC implementation using in-memory Map storage.
- *
- * Use cases:
- * - POC demonstrations
- * - Testing without remote state backend
- * - Development and debugging
- * - CI/CD validation
- *
- * This is a standalone implementation, NOT a base class.
- *
- * @example
- * ```typescript
- * const provider = new DummyBackendProvider();
- * await provider.initialize();
- * await provider.saveState('stack', { cloudDOM: [...] });
- * const state = await provider.getState('stack');
- * ```
- */
-export declare class DummyBackendProvider implements IBackendProvider {
-    private state;
-    private initialized;
-    private locks;
-    private auditLogs;
-    private snapshots;
-    /**
-     * Optional initialization (simulates async setup)
-     * REQ-04.4: Support async initialization
-     */
-    initialize(): Promise<void>;
-    /**
-     * Check if provider is initialized
-     * Useful for integration testing
-     */
-    isInitialized(): boolean;
-    /**
-     * Retrieve state for a given stack
-     * Returns undefined if no state exists
-     *
-     * REQ-04: Core provider interface implementation
-     * REQ-05: State management for deployment tracking
-     * REQ-06: Universal output access
-     *
-     * @param stackName - Name of the stack to retrieve state for
-     * @returns Promise resolving to stack state, or undefined if not found
-     */
-    getState(stackName: string): Promise<any | undefined>;
-    /**
-     * Save state for a given stack
-     *
-     * REQ-04: Core provider interface implementation
-     * REQ-05: State management for deployment tracking
-     * REQ-08.5: Store migration map versions in backend state
-     *
-     * @param stackName - Name of the stack to save state for
-     * @param state - State object to persist (CloudDOM, outputs, metadata)
-     * @returns Promise that resolves when state is saved
-     */
-    saveState(stackName: string, state: any): Promise<void>;
-    /**
-     * Helper method: Clear all state (useful for testing)
-     * Not part of IBackendProvider interface
-     */
-    clearAll(): void;
-    /**
-     * Helper method: Get all state (useful for debugging)
-     * Not part of IBackendProvider interface
-     *
-     * @returns Map of all stack states
-     */
-    getAllState(): Map<string, any>;
-    /**
-     * Acquire lock for a stack (optional method for StateMachine)
-     * REQ-O02: State locking to prevent concurrent deployments
-     *
-     * @param stackName - Name of the stack to lock
-     * @param holder - Identifier of the lock holder (user/process)
-     * @param ttl - Time-to-live in seconds
-     * @throws Error if lock is already held and not expired
-     */
-    acquireLock(stackName: string, holder: string, ttl: number): Promise<void>;
-    /**
-     * Release lock for a stack (optional method for StateMachine)
-     * REQ-O02: State locking to prevent concurrent deployments
-     *
-     * @param stackName - Name of the stack to unlock
-     */
-    releaseLock(stackName: string): Promise<void>;
-    /**
-     * Check lock status for a stack (optional method for StateMachine)
-     * REQ-O02: State locking to prevent concurrent deployments
-     *
-     * @param stackName - Name of the stack to check
-     * @returns Lock info if lock exists, null otherwise
-     */
-    checkLock(stackName: string): Promise<{
-        holder: string;
-        acquiredAt: number;
-        ttl: number;
-    } | null>;
-    /**
-     * Append audit log entry (optional method for StateMachine)
-     * REQ-O05: Audit log for compliance and debugging
-     *
-     * @param stackName - Name of the stack
-     * @param entry - Audit log entry to append
-     */
-    appendAuditLog(stackName: string, entry: any): Promise<void>;
-    /**
-     * Save state snapshot (optional method for StateMachine)
-     * REQ-O01: State snapshots for time-travel debugging
-     *
-     * @param stackName - Name of the stack
-     * @param state - State snapshot to save
-     */
-    saveSnapshot(stackName: string, state: any): Promise<void>;
-    /**
-     * Helper method: Check if lock exists (useful for testing)
-     * Not part of IBackendProvider interface
-     */
-    hasLock(stackName: string): boolean;
-    /**
-     * Helper method: Get audit logs (useful for testing)
-     * Not part of IBackendProvider interface
-     */
-    getAuditLogs(stackName: string): any[];
-    /**
-     * Helper method: Get snapshots (useful for testing)
-     * Not part of IBackendProvider interface
-     */
-    getSnapshots(stackName: string): any[];
-}

package/dist/providers/DummyBackendProvider.js

@@ -1,189 +0,0 @@
-"use strict";
-// REQ-04: Dummy backend provider implementation for POC and testing
-// REQ-05: State management for deployment tracking
-// REQ-06: Universal output access
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DummyBackendProvider = void 0;
-/**
- * DummyBackendProvider is a POC implementation using in-memory Map storage.
- *
- * Use cases:
- * - POC demonstrations
- * - Testing without remote state backend
- * - Development and debugging
- * - CI/CD validation
- *
- * This is a standalone implementation, NOT a base class.
- *
- * @example
- * ```typescript
- * const provider = new DummyBackendProvider();
- * await provider.initialize();
- * await provider.saveState('stack', { cloudDOM: [...] });
- * const state = await provider.getState('stack');
- * ```
- */
-class DummyBackendProvider {
-    constructor() {
-        this.state = new Map();
-        this.initialized = false;
-        this.locks = new Map();
-        this.auditLogs = new Map();
-        this.snapshots = new Map();
-    }
-    /**
-     * Optional initialization (simulates async setup)
-     * REQ-04.4: Support async initialization
-     */
-    async initialize() {
-        console.log('[DummyBackendProvider] Initializing...');
-        this.initialized = true;
-    }
-    /**
-     * Check if provider is initialized
-     * Useful for integration testing
-     */
-    isInitialized() {
-        return this.initialized;
-    }
-    /**
-     * Retrieve state for a given stack
-     * Returns undefined if no state exists
-     *
-     * REQ-04: Core provider interface implementation
-     * REQ-05: State management for deployment tracking
-     * REQ-06: Universal output access
-     *
-     * @param stackName - Name of the stack to retrieve state for
-     * @returns Promise resolving to stack state, or undefined if not found
-     */
-    async getState(stackName) {
-        console.debug(`[DummyBackendProvider] Getting state for stack: ${stackName}`);
-        return this.state.get(stackName);
-    }
-    /**
-     * Save state for a given stack
-     *
-     * REQ-04: Core provider interface implementation
-     * REQ-05: State management for deployment tracking
-     * REQ-08.5: Store migration map versions in backend state
-     *
-     * @param stackName - Name of the stack to save state for
-     * @param state - State object to persist (CloudDOM, outputs, metadata)
-     * @returns Promise that resolves when state is saved
-     */
-    async saveState(stackName, state) {
-        console.debug(`[DummyBackendProvider] Saving state for stack: ${stackName}`);
-        this.state.set(stackName, state);
-    }
-    /**
-     * Helper method: Clear all state (useful for testing)
-     * Not part of IBackendProvider interface
-     */
-    clearAll() {
-        console.debug('[DummyBackendProvider] Clearing all state');
-        this.state.clear();
-    }
-    /**
-     * Helper method: Get all state (useful for debugging)
-     * Not part of IBackendProvider interface
-     *
-     * @returns Map of all stack states
-     */
-    getAllState() {
-        return new Map(this.state);
-    }
-    /**
-     * Acquire lock for a stack (optional method for StateMachine)
-     * REQ-O02: State locking to prevent concurrent deployments
-     *
-     * @param stackName - Name of the stack to lock
-     * @param holder - Identifier of the lock holder (user/process)
-     * @param ttl - Time-to-live in seconds
-     * @throws Error if lock is already held and not expired
-     */
-    async acquireLock(stackName, holder, ttl) {
-        const existingLock = this.locks.get(stackName);
-        if (existingLock) {
-            const now = Date.now();
-            const lockAge = now - existingLock.acquiredAt;
-            const lockTTL = existingLock.ttl * 1000; // Convert to milliseconds
-            if (lockAge < lockTTL) {
-                throw new Error(`Stack "${stackName}" is locked by ${existingLock.holder} ` +
-                    `(acquired ${new Date(existingLock.acquiredAt).toISOString()})`);
-            }
-        }
-        this.locks.set(stackName, { holder, acquiredAt: Date.now(), ttl });
-        console.debug(`[DummyBackendProvider] Lock acquired for stack: ${stackName} by ${holder}`);
-    }
-    /**
-     * Release lock for a stack (optional method for StateMachine)
-     * REQ-O02: State locking to prevent concurrent deployments
-     *
-     * @param stackName - Name of the stack to unlock
-     */
-    async releaseLock(stackName) {
-        this.locks.delete(stackName);
-        console.debug(`[DummyBackendProvider] Lock released for stack: ${stackName}`);
-    }
-    /**
-     * Check lock status for a stack (optional method for StateMachine)
-     * REQ-O02: State locking to prevent concurrent deployments
-     *
-     * @param stackName - Name of the stack to check
-     * @returns Lock info if lock exists, null otherwise
-     */
-    async checkLock(stackName) {
-        return this.locks.get(stackName) || null;
-    }
-    /**
-     * Append audit log entry (optional method for StateMachine)
-     * REQ-O05: Audit log for compliance and debugging
-     *
-     * @param stackName - Name of the stack
-     * @param entry - Audit log entry to append
-     */
-    async appendAuditLog(stackName, entry) {
-        if (!this.auditLogs.has(stackName)) {
-            this.auditLogs.set(stackName, []);
-        }
-        this.auditLogs.get(stackName).push(entry);
-        console.debug(`[DummyBackendProvider] Audit log entry appended for stack: ${stackName}`);
-    }
-    /**
-     * Save state snapshot (optional method for StateMachine)
-     * REQ-O01: State snapshots for time-travel debugging
-     *
-     * @param stackName - Name of the stack
-     * @param state - State snapshot to save
-     */
-    async saveSnapshot(stackName, state) {
-        if (!this.snapshots.has(stackName)) {
-            this.snapshots.set(stackName, []);
-        }
-        this.snapshots.get(stackName).push(state);
-        console.debug(`[DummyBackendProvider] Snapshot saved for stack: ${stackName}`);
-    }
-    /**
-     * Helper method: Check if lock exists (useful for testing)
-     * Not part of IBackendProvider interface
-     */
-    hasLock(stackName) {
-        return this.locks.has(stackName);
-    }
-    /**
-     * Helper method: Get audit logs (useful for testing)
-     * Not part of IBackendProvider interface
-     */
-    getAuditLogs(stackName) {
-        return this.auditLogs.get(stackName) || [];
-    }
-    /**
-     * Helper method: Get snapshots (useful for testing)
-     * Not part of IBackendProvider interface
-     */
-    getSnapshots(stackName) {
-        return this.snapshots.get(stackName) || [];
-    }
-}
-exports.DummyBackendProvider = DummyBackendProvider;

package/dist/providers/DummyCloudProvider.d.ts

@@ -1,128 +0,0 @@
-/**
-
- * Licensed under the Apache License, Version 2.0 (the "License");
-
- * you may not use this file except in compliance with the License.
-
- * You may obtain a copy of the License at
-
- *
-
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- *
-
- * Unless required by applicable law or agreed to in writing, software
-
- * distributed under the License is distributed on an "AS IS" BASIS,
-
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
- * See the License for the specific language governing permissions and
-
- * limitations under the License.
-
- *
-
- * Copyright 2025 Daniel Coutinho Ribeiro
-
- */
-
-/**
-
- * Licensed under the Apache License, Version 2.0 (the "License");
-
- * you may not use this file except in compliance with the License.
-
- * You may obtain a copy of the License at
-
- *
-
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- *
-
- * Unless required by applicable law or agreed to in writing, software
-
- * distributed under the License is distributed on an "AS IS" BASIS,
-
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
- * See the License for the specific language governing permissions and
-
- * limitations under the License.
-
- *
-
- * Copyright 2025 Daniel Coutinho Ribeiro
-
- */
-
-import { ICloudProvider, CloudDOMNode } from './ICloudProvider';
-/**
- * DummyCloudProvider is a POC implementation that logs CloudDOM structure
- * instead of deploying actual infrastructure.
- *
- * Use cases:
- * - POC demonstrations
- * - Testing without cloud credentials
- * - Development and debugging
- * - CI/CD validation
- *
- * This is a standalone implementation, NOT a base class.
- *
- * @example
- * ```typescript
- * const provider = new DummyCloudProvider();
- * await provider.initialize();
- * provider.materialize(cloudDOM);
- * ```
- */
-export declare class DummyCloudProvider implements ICloudProvider {
-    private initialized;
-    /**
-     * Optional initialization (simulates async setup)
-     * REQ-04.4: Support async initialization
-     */
-    initialize(): Promise<void>;
-    /**
-     * Check if provider is initialized
-     * Useful for integration testing
-     */
-    isInitialized(): boolean;
-    /**
-     * Materialize CloudDOM by logging structure with indentation
-     * REQ-04: Core provider interface implementation
-     *
-     * @param cloudDOM - Array of CloudDOM nodes to materialize
-     */
-    materialize(cloudDOM: CloudDOMNode[]): void;
-    /**
-     * Recursively log CloudDOM node with indentation
-     * Outputs are logged in format: nodeId.outputKey = value
-     */
-    private logNode;
-    /**
-     * Safely stringify objects, handling circular references and non-JSON values
-     */
-    private safeStringify;
-    /**
-     * JSON replacer function that handles circular references
-     */
-    private getCircularReplacer;
-    /**
-     * Optional lifecycle hook: called before deployment
-     * REQ-09.1: preDeploy lifecycle hook
-     */
-    preDeploy(cloudDOM: CloudDOMNode[]): Promise<void>;
-    /**
-     * Optional lifecycle hook: called after successful deployment
-     * REQ-09.2: postDeploy lifecycle hook
-     */
-    postDeploy(cloudDOM: CloudDOMNode[], outputs: Record<string, any>): Promise<void>;
-    /**
-     * Optional lifecycle hook: called when deployment fails
-     * REQ-09.3: onError lifecycle hook
-     */
-    onError(error: Error, cloudDOM: CloudDOMNode[]): Promise<void>;
-}

package/dist/providers/DummyCloudProvider.js

@@ -1,157 +0,0 @@
-"use strict";
-// REQ-04: Dummy provider implementation for POC and testing
-// REQ-09: Lifecycle hooks implementation
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DummyCloudProvider = void 0;
-/**
- * DummyCloudProvider is a POC implementation that logs CloudDOM structure
- * instead of deploying actual infrastructure.
- *
- * Use cases:
- * - POC demonstrations
- * - Testing without cloud credentials
- * - Development and debugging
- * - CI/CD validation
- *
- * This is a standalone implementation, NOT a base class.
- *
- * @example
- * ```typescript
- * const provider = new DummyCloudProvider();
- * await provider.initialize();
- * provider.materialize(cloudDOM);
- * ```
- */
-class DummyCloudProvider {
-    constructor() {
-        this.initialized = false;
-    }
-    /**
-     * Optional initialization (simulates async setup)
-     * REQ-04.4: Support async initialization
-     */
-    async initialize() {
-        console.log('[DummyCloudProvider] Initializing...');
-        this.initialized = true;
-    }
-    /**
-     * Check if provider is initialized
-     * Useful for integration testing
-     */
-    isInitialized() {
-        return this.initialized;
-    }
-    /**
-     * Materialize CloudDOM by logging structure with indentation
-     * REQ-04: Core provider interface implementation
-     *
-     * @param cloudDOM - Array of CloudDOM nodes to materialize
-     */
-    materialize(cloudDOM) {
-        console.debug('\n=== DummyCloudProvider: Materializing CloudDOM ===\n');
-        cloudDOM.forEach((node) => {
-            this.logNode(node, 0);
-        });
-        console.debug('\n=== Materialization Complete ===\n');
-    }
-    /**
-     * Recursively log CloudDOM node with indentation
-     * Outputs are logged in format: nodeId.outputKey = value
-     */
-    logNode(node, depth, visited = new Set()) {
-        // Prevent infinite recursion from circular references
-        if (visited.has(node)) {
-            const indent = '  '.repeat(depth);
-            console.debug(`${indent}[Circular reference to ${node.id}]`);
-            return;
-        }
-        visited.add(node);
-        // Limit depth to prevent stack overflow
-        if (depth > 50) {
-            const indent = '  '.repeat(depth);
-            console.debug(`${indent}[Max depth reached]`);
-            return;
-        }
-        const indent = '  '.repeat(depth);
-        // Log resource
-        console.debug(`${indent}Deploying: ${node.id} (${node.construct?.name || 'Unknown'})`);
-        // Safely log props (handle undefined/null)
-        const propsStr = this.safeStringify(node.props || {}, 2);
-        const propsLines = propsStr.split('\n');
-        console.debug(`${indent}  Props: ${propsLines.join(`\n${indent}  `)}`);
-        // Log outputs
-        if (node.outputs && Object.keys(node.outputs).length > 0) {
-            console.debug(`${indent}  Outputs:`);
-            Object.entries(node.outputs).forEach(([outputKey, value]) => {
-                console.debug(`${indent}    ${node.id}.${outputKey} = ${this.safeStringify(value)}`);
-            });
-        }
-        // Log children recursively
-        if (node.children && node.children.length > 0) {
-            node.children.forEach((child) => {
-                this.logNode(child, depth + 1, visited);
-            });
-        }
-    }
-    /**
-     * Safely stringify objects, handling circular references and non-JSON values
-     */
-    safeStringify(obj, indent) {
-        try {
-            return JSON.stringify(obj, this.getCircularReplacer(), indent);
-        }
-        catch {
-            return '[Unable to stringify: contains circular references or non-JSON values]';
-        }
-    }
-    /**
-     * JSON replacer function that handles circular references
-     */
-    getCircularReplacer() {
-        const seen = new WeakSet();
-        return (key, value) => {
-            if (typeof value === 'object' && value !== null) {
-                if (seen.has(value)) {
-                    return '[Circular]';
-                }
-                seen.add(value);
-            }
-            // Handle functions
-            if (typeof value === 'function') {
-                return '[Function]';
-            }
-            // Handle symbols
-            if (typeof value === 'symbol') {
-                return '[Symbol]';
-            }
-            return value;
-        };
-    }
-    /**
-     * Optional lifecycle hook: called before deployment
-     * REQ-09.1: preDeploy lifecycle hook
-     */
-    async preDeploy(cloudDOM) {
-        console.debug('[DummyCloudProvider] preDeploy hook called');
-        console.debug(`[DummyCloudProvider] Validating ${cloudDOM.length} resources...`);
-    }
-    /**
-     * Optional lifecycle hook: called after successful deployment
-     * REQ-09.2: postDeploy lifecycle hook
-     */
-    async postDeploy(cloudDOM, outputs) {
-        console.debug('[DummyCloudProvider] postDeploy hook called');
-        console.debug(`[DummyCloudProvider] Deployed ${cloudDOM.length} resources`);
-        console.debug(`[DummyCloudProvider] Collected ${Object.keys(outputs).length} outputs`);
-    }
-    /**
-     * Optional lifecycle hook: called when deployment fails
-     * REQ-09.3: onError lifecycle hook
-     */
-    async onError(error, cloudDOM) {
-        console.error('[DummyCloudProvider] onError hook called');
-        console.error(`[DummyCloudProvider] Deployment failed: ${error.message}`);
-        console.error(`[DummyCloudProvider] Failed while deploying ${cloudDOM.length} resources`);
-    }
-}
-exports.DummyCloudProvider = DummyCloudProvider;