@fromeroc9/testform 1.0.3 → 1.0.5

package/dist/core/backends/azurerm.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureRMBackend = void 0;
+const storage_blob_1 = require("@azure/storage-blob");
+const crypto_1 = require("crypto");
+const const_1 = require("../../const");
+class AzureRMBackend {
+    config;
+    workspace;
+    containerClient;
+    blobClient;
+    currentLeaseId;
+    originalKey;
+    constructor(config, workspace = 'default') {
+        this.config = config;
+        this.workspace = workspace;
+        const connectionString = config.connection_string || process.env.AZURE_STORAGE_CONNECTION_STRING;
+        if (!connectionString) {
+            const error = new Error("AZURE_STORAGE_CONNECTION_STRING env variable is missing");
+            error.name = 'AzureRM Backend Configuration Error';
+            throw error;
+        }
+        const blobServiceClient = storage_blob_1.BlobServiceClient.fromConnectionString(connectionString);
+        this.containerClient = blobServiceClient.getContainerClient(config.container_name);
+        this.config.key = this.config.key || const_1.FILE_STATE;
+        this.originalKey = this.config.key;
+        if (this.workspace !== 'default') {
+            this.config.key = `env:/${this.workspace}/${this.originalKey}`;
+        }
+        this.blobClient = this.containerClient.getBlockBlobClient(this.config.key);
+    }
+    async exists() {
+        try {
+            return await this.blobClient.exists();
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async read() {
+        try {
+            await this.containerClient.createIfNotExists();
+            const exists = await this.blobClient.exists();
+            if (!exists) {
+                return this.emptyState();
+            }
+            const response = await this.blobClient.download(0);
+            const raw = await this.streamToString(response.readableStreamBody);
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            return this.emptyState();
+        }
+    }
+    async write(state) {
+        await this.containerClient.createIfNotExists();
+        const content = JSON.stringify(state, null, 2);
+        const options = { blobHTTPHeaders: { blobContentType: 'application/json' } };
+        if (this.currentLeaseId) {
+            options.conditions = { leaseId: this.currentLeaseId };
+        }
+        await this.blobClient.upload(content, content.length, options);
+    }
+    async lock(timeoutRaw) {
+        const timeoutMatch = timeoutRaw.match(/^(\d+)s$/);
+        const timeoutMs = timeoutMatch ? parseInt(timeoutMatch[1], 10) * 1000 : 0;
+        const start = Date.now();
+        // Ensure blob exists before leasing
+        const exists = await this.blobClient.exists();
+        if (!exists) {
+            await this.write(this.emptyState());
+        }
+        const leaseClient = this.blobClient.getBlobLeaseClient();
+        while (true) {
+            try {
+                // -1 means infinite lease
+                const response = await leaseClient.acquireLease(-1);
+                this.currentLeaseId = response.leaseId;
+                // Write lock metadata
+                try {
+                    await this.blobClient.setMetadata({
+                        id: (0, crypto_1.randomUUID)(),
+                        operation: 'Operation',
+                        who: process.env.USER || 'unknown',
+                        created: new Date().toISOString()
+                    }, { conditions: { leaseId: this.currentLeaseId } });
+                }
+                catch (metaErr) {
+                    // Floci emulator bug workaround: it returns 201 Created instead of 200 OK
+                    // for setMetadata, which crashes the strict Azure SDK.
+                    if (metaErr.statusCode !== 201) {
+                        throw metaErr;
+                    }
+                }
+                return true;
+            }
+            catch (err) {
+                if (err.statusCode === 409 || err.code === 'LeaseAlreadyPresent') {
+                    if (Date.now() - start >= timeoutMs) {
+                        return false;
+                    }
+                    await new Promise(r => setTimeout(r, 1000));
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    async unlock() {
+        if (!this.currentLeaseId)
+            return true;
+        try {
+            const leaseClient = this.blobClient.getBlobLeaseClient(this.currentLeaseId);
+            await leaseClient.releaseLease();
+            this.currentLeaseId = undefined;
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async forceUnlock(lockId) {
+        try {
+            const props = await this.blobClient.getProperties();
+            const currentLockId = props.metadata?.id;
+            if (props.leaseState === 'available') {
+                return { success: false, error: 'No lock exists for the given state.' };
+            }
+            if (currentLockId !== lockId) {
+                return { success: false, currentLockId: currentLockId || 'unknown' };
+            }
+            // Break the lease
+            const leaseClient = this.blobClient.getBlobLeaseClient();
+            await leaseClient.breakLease(0);
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to force unlock: ${err.message}` };
+        }
+    }
+    async isLocked() {
+        try {
+            const props = await this.blobClient.getProperties();
+            return props.leaseState !== 'available';
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    emptyState() {
+        return {
+            version: const_1.VERSION_STATE,
+            serial: 0,
+            lineage: (0, crypto_1.randomUUID)(),
+            lastSync: '',
+            resources: [],
+        };
+    }
+    async streamToString(readableStream) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            readableStream.on("data", (data) => {
+                chunks.push(data.toString());
+            });
+            readableStream.on("end", () => {
+                resolve(chunks.join(""));
+            });
+            readableStream.on("error", reject);
+        });
+    }
+    async listWorkspaces() {
+        const workspaces = new Set(['default']);
+        try {
+            for await (const blob of this.containerClient.listBlobsFlat({ prefix: 'env:/' })) {
+                const match = blob.name.match(/^env:\/([^\/]+)\//);
+                if (match) {
+                    workspaces.add(match[1]);
+                }
+            }
+        }
+        catch (e) {
+            // fallback
+        }
+        return Array.from(workspaces);
+    }
+    async deleteWorkspace(name) {
+        if (name === 'default')
+            return false;
+        try {
+            const targetKey = `env:/${name}/${this.originalKey}`;
+            const targetClient = this.containerClient.getBlockBlobClient(targetKey);
+            await targetClient.deleteIfExists();
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+exports.AzureRMBackend = AzureRMBackend;

package/dist/core/backends/backend.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/backends/gcs.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GCSBackend = void 0;
+const storage_1 = require("@google-cloud/storage");
+const crypto_1 = require("crypto");
+const const_1 = require("../../const");
+class GCSBackend {
+    config;
+    workspace;
+    storage;
+    bucketClient;
+    stateKey;
+    lockKey;
+    lockId;
+    constructor(config, workspace = 'default') {
+        this.config = config;
+        this.workspace = workspace;
+        const storageOptions = {};
+        if (config.credentials) {
+            storageOptions.keyFilename = config.credentials;
+        }
+        this.storage = new storage_1.Storage(storageOptions);
+        this.bucketClient = this.storage.bucket(config.bucket);
+        let prefix = this.config.prefix || '';
+        if (prefix && !prefix.endsWith('/')) {
+            prefix += '/';
+        }
+        const originalKey = const_1.FILE_STATE;
+        if (this.workspace !== 'default') {
+            this.stateKey = `${prefix}env:/${this.workspace}/${originalKey}`;
+        }
+        else {
+            this.stateKey = `${prefix}${originalKey}`;
+        }
+        this.lockKey = `${this.stateKey}.tflock`;
+    }
+    emptyState() {
+        return {
+            version: const_1.VERSION_STATE,
+            serial: 0,
+            lineage: (0, crypto_1.randomUUID)(),
+            lastSync: '',
+            resources: []
+        };
+    }
+    async exists() {
+        try {
+            const [exists] = await this.bucketClient.file(this.config.prefix).exists();
+            return exists;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async read() {
+        try {
+            const file = this.bucketClient.file(this.stateKey);
+            const [exists] = await file.exists();
+            if (!exists) {
+                return this.emptyState();
+            }
+            const [content] = await file.download();
+            return JSON.parse(content.toString('utf8'));
+        }
+        catch (err) {
+            return this.emptyState();
+        }
+    }
+    async write(state) {
+        const file = this.bucketClient.file(this.stateKey);
+        const content = JSON.stringify(state, null, 2);
+        await file.save(content, {
+            contentType: 'application/json'
+        });
+    }
+    async lock(timeoutRaw) {
+        const timeoutMatch = timeoutRaw.match(/^(\d+)s$/);
+        const timeoutMs = timeoutMatch ? parseInt(timeoutMatch[1], 10) * 1000 : 0;
+        const start = Date.now();
+        const file = this.bucketClient.file(this.lockKey);
+        const lockPayload = JSON.stringify({
+            id: (0, crypto_1.randomUUID)(),
+            operation: 'Operation',
+            who: process.env.USER || 'unknown',
+            created: new Date().toISOString()
+        });
+        while (true) {
+            try {
+                // ifGenerationMatch: 0 ensures the file is created ONLY if it does not already exist.
+                await file.save(lockPayload, {
+                    preconditionOpts: { ifGenerationMatch: 0 }
+                });
+                this.lockId = lockPayload;
+                return true;
+            }
+            catch (err) {
+                // 412 Precondition Failed means the file already exists (lock is acquired by someone else)
+                if (err.code === 412 || err.code === '412') {
+                    if (Date.now() - start >= timeoutMs) {
+                        return false;
+                    }
+                    await new Promise(r => setTimeout(r, 1000));
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    async unlock() {
+        if (!this.lockId)
+            return true;
+        const file = this.bucketClient.file(this.lockKey);
+        try {
+            const [exists] = await file.exists();
+            if (exists) {
+                await file.delete();
+            }
+            this.lockId = undefined;
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async forceUnlock(id) {
+        const file = this.bucketClient.file(this.lockKey);
+        try {
+            const [exists] = await file.exists();
+            if (!exists) {
+                return { success: false, error: 'No lock exists for the given state.' };
+            }
+            const [content] = await file.download();
+            const info = JSON.parse(content.toString('utf8'));
+            if (info.id !== id) {
+                return { success: false, currentLockId: info.id };
+            }
+            await file.delete();
+            this.lockId = undefined;
+            return { success: true };
+        }
+        catch (e) {
+            return { success: false, error: e.message };
+        }
+    }
+    async isLocked() {
+        const file = this.bucketClient.file(this.lockKey);
+        try {
+            const [exists] = await file.exists();
+            return exists;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async listWorkspaces() {
+        const workspaces = new Set(['default']);
+        try {
+            let prefix = this.config.prefix || '';
+            if (prefix && !prefix.endsWith('/')) {
+                prefix += '/';
+            }
+            const searchPrefix = `${prefix}env:/`;
+            const [files] = await this.bucketClient.getFiles({ prefix: searchPrefix });
+            for (const file of files) {
+                const relName = file.name.substring(searchPrefix.length);
+                const match = relName.match(/^([^\/]+)\//);
+                if (match) {
+                    workspaces.add(match[1]);
+                }
+            }
+        }
+        catch (e) {
+            // fallback
+        }
+        return Array.from(workspaces);
+    }
+    async deleteWorkspace(name) {
+        if (name === 'default')
+            return false;
+        try {
+            let prefix = this.config.prefix || '';
+            if (prefix && !prefix.endsWith('/')) {
+                prefix += '/';
+            }
+            const targetKey = `${prefix}env:/${name}/${const_1.FILE_STATE}`;
+            const targetClient = this.bucketClient.file(targetKey);
+            const [exists] = await targetClient.exists();
+            if (exists) {
+                await targetClient.delete();
+                return true;
+            }
+            return false;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+exports.GCSBackend = GCSBackend;

package/dist/core/backends/local.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalBackend = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const const_1 = require("../../const");
+class LocalBackend {
+    dir;
+    customStatePath;
+    customBackupPath;
+    workspace;
+    constructor(dir, customStatePath, customBackupPath, workspace = 'default') {
+        this.dir = dir;
+        this.customStatePath = customStatePath;
+        this.customBackupPath = customBackupPath;
+        this.workspace = workspace;
+    }
+    getWorkspaceStatePath() {
+        if (this.customStatePath) {
+            return (0, path_1.resolve)(this.dir, this.customStatePath);
+        }
+        if (this.workspace !== 'default') {
+            return (0, path_1.resolve)(this.dir, `${const_1.FILE_STATE}.d`, this.workspace, const_1.FILE_STATE);
+        }
+        return (0, path_1.resolve)(this.dir, const_1.FILE_STATE);
+    }
+    resolvePath() {
+        const path = this.getWorkspaceStatePath();
+        if ((0, fs_1.existsSync)(path))
+            return path;
+        if (this.workspace === 'default') {
+            const cwd = (0, path_1.resolve)(this.dir, const_1.FILE_STATE);
+            if ((0, fs_1.existsSync)(cwd))
+                return cwd;
+        }
+        return null;
+    }
+    lockPath() {
+        const path = this.resolvePath() ?? this.getWorkspaceStatePath();
+        return `${path}.lock`;
+    }
+    async exists() {
+        return this.resolvePath() !== null;
+    }
+    async read() {
+        const path = this.resolvePath();
+        if (!path || !(0, fs_1.existsSync)(path)) {
+            return {
+                version: const_1.VERSION_STATE,
+                serial: 0,
+                lineage: (0, crypto_1.randomUUID)(),
+                lastSync: '',
+                resources: [],
+            };
+        }
+        const raw = await fs_1.promises.readFile(path, "utf-8");
+        return JSON.parse(raw);
+    }
+    async write(state) {
+        const path = this.resolvePath() ?? this.getWorkspaceStatePath();
+        // Ensure directory exists
+        const dirPath = (0, path_1.resolve)(path, '..');
+        if (!(0, fs_1.existsSync)(dirPath)) {
+            await fs_1.promises.mkdir(dirPath, { recursive: true });
+        }
+        const backupPath = this.customBackupPath ?
+            (0, path_1.resolve)(this.dir, this.customBackupPath) :
+            `${path}.backup`;
+        if ((0, fs_1.existsSync)(path)) {
+            await fs_1.promises.copyFile(path, backupPath);
+        }
+        await fs_1.promises.writeFile(path, JSON.stringify(state, null, 2), "utf-8");
+    }
+    async lock(timeoutRaw) {
+        const timeoutMatch = timeoutRaw.match(/^(\d+)s$/);
+        const timeoutMs = timeoutMatch ? parseInt(timeoutMatch[1], 10) * 1000 : 0;
+        const lockFile = this.lockPath();
+        const start = Date.now();
+        while (true) {
+            try {
+                // wx flag: open for writing, fails if the file exists
+                await fs_1.promises.writeFile(lockFile, JSON.stringify({
+                    id: (0, crypto_1.randomUUID)(),
+                    operation: 'Operation',
+                    who: process.env.USER || 'unknown',
+                    created: new Date().toISOString()
+                }, null, 2), { flag: 'wx' });
+                return true;
+            }
+            catch (err) {
+                if (err.code === 'EEXIST') {
+                    if (Date.now() - start >= timeoutMs) {
+                        return false;
+                    }
+                    await new Promise(r => setTimeout(r, 1000));
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    async unlock() {
+        const lockFile = this.lockPath();
+        if ((0, fs_1.existsSync)(lockFile)) {
+            try {
+                await fs_1.promises.unlink(lockFile);
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async forceUnlock(lockId) {
+        const lockFile = this.lockPath();
+        if (!(0, fs_1.existsSync)(lockFile)) {
+            return { success: false, error: `No lock exists for the given state. (Path checked: ${lockFile})` };
+        }
+        try {
+            const raw = await fs_1.promises.readFile(lockFile, 'utf-8');
+            const info = JSON.parse(raw);
+            if (info.id !== lockId) {
+                return { success: false, currentLockId: info.id };
+            }
+            await fs_1.promises.unlink(lockFile);
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: `The lock file could not be read or parsed.` };
+        }
+    }
+    async isLocked() {
+        return (0, fs_1.existsSync)(this.lockPath());
+    }
+    async listWorkspaces() {
+        const workspaces = ['default'];
+        const dPath = (0, path_1.resolve)(this.dir, `${const_1.FILE_STATE}.d`);
+        if ((0, fs_1.existsSync)(dPath)) {
+            const entries = await fs_1.promises.readdir(dPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    workspaces.push(entry.name);
+                }
+            }
+        }
+        return workspaces;
+    }
+    async deleteWorkspace(name) {
+        if (name === 'default')
+            return false;
+        const wPath = (0, path_1.resolve)(this.dir, `${const_1.FILE_STATE}.d`, name);
+        if ((0, fs_1.existsSync)(wPath)) {
+            await fs_1.promises.rm(wPath, { recursive: true, force: true });
+            return true;
+        }
+        return false;
+    }
+}
+exports.LocalBackend = LocalBackend;