ts-prorm-orm 1.1.0

package/dist/compliance/worm-storage.js

@@ -0,0 +1,712 @@
+"use strict";
+/**
+ * WORMStorage (Write Once Read Many)
+ *
+ * Immutable archival storage that prevents UPDATE and DELETE operations after commit.
+ * Provides tamper-evident audit trails and retention period enforcement.
+ *
+ * Covers compliance frameworks including:
+ *   SEC 17a-4 (WORM), FINRA, SOX, DORA, MiFID II, GDPR Art 32,
+ *   ALCOA+, 21 CFR Part 11, and financial audit requirements.
+ *
+ * Usage:
+ *   // Enable WORM on a model:
+ *   WORMStorage.enable(FinancialRecord, {
+ *     retentionPeriod: { years: 7 },
+ *     tamperEvident: true,
+ *   });
+ *
+ *   // Archive a record (moves to archived state):
+ *   await WORMStorage.archive(record);
+ *
+ *   // Freeze a record (fully immutable):
+ *   await WORMStorage.freeze(record);
+ *
+ *   // Verify integrity of a record:
+ *   const isValid = await WORMStorage.verifyIntegrity(recordId, 'FinancialRecords');
+ *
+ *   // Get tamper evidence log:
+ *   const log = await WORMStorage.getTamperLog(recordId, 'FinancialRecords');
+ *
+ *   // Enforce retention policy:
+ *   await WORMStorage.enforceRetention(FinancialRecord, prorm);
+ *
+ *   // Using the decorator:
+ *   @WORM({ retentionPeriod: { years: 7 }, tamperEvident: true })
+ *   class FinancialRecord extends Model { ... }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORMStorage = void 0;
+exports.WORM = WORM;
+exports.getWORMOptions = getWORMOptions;
+exports.applyWORMHooks = applyWORMHooks;
+exports.isFrozen = isFrozen;
+exports.isArchived = isArchived;
+const crypto_1 = require("crypto");
+const data_types_1 = require("../models/data-types");
+const data_retention_1 = require("./data-retention");
+// ==================== Symbol Keys ====================
+const WORM_OPTIONS_KEY = '__orm_worm_options__';
+// ==================== Registry ====================
+const wormRegistry = new Map();
+// ==================== Hash Utilities ====================
+/**
+ * Cryptographic hash for tamper detection.
+ * Uses SHA-256 (via Node's built-in crypto module) over a canonical
+ * (sorted-key) JSON representation of the record data plus the previous
+ * hash in the chain, so the result is deterministic regardless of key
+ * insertion order and each entry is cryptographically bound to its
+ * predecessor.
+ */
+function computeHash(data, previousHash = '') {
+    const content = stableStringify(data) + previousHash;
+    return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+}
+/**
+ * Deterministically stringify an object by sorting object keys at every
+ * level, so semantically identical records always hash to the same value.
+ */
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => stableStringify(v)).join(',')}]`;
+    }
+    if (value instanceof Date) {
+        return JSON.stringify(value.toISOString());
+    }
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(',')}}`;
+}
+// ==================== Model Creation ====================
+function createWORMMetadataModel(prorm, tableName, stateField) {
+    const MetadataModel = prorm.define('WORMMetadata', {
+        id: {
+            type: data_types_1.DataTypes.INTEGER(),
+            primaryKey: true,
+            autoIncrement: true,
+        },
+        recordId: {
+            type: data_types_1.DataTypes.STRING(),
+            allowNull: false,
+        },
+        tableName: {
+            type: data_types_1.DataTypes.STRING(),
+            allowNull: false,
+        },
+        state: {
+            type: data_types_1.DataTypes.ENUM('active', 'archived', 'frozen'),
+            allowNull: false,
+            defaultValue: 'active',
+        },
+        archivedAt: {
+            type: data_types_1.DataTypes.DATE,
+            allowNull: true,
+        },
+        frozenAt: {
+            type: data_types_1.DataTypes.DATE,
+            allowNull: true,
+        },
+        retentionUntil: {
+            type: data_types_1.DataTypes.DATE,
+            allowNull: true,
+        },
+    }, {
+        tableName,
+        timestamps: true,
+        indexes: [
+            { fields: ['recordId', 'tableName'] },
+            { fields: ['state'] },
+            { fields: ['retentionUntil'] },
+        ],
+    });
+    return MetadataModel;
+}
+function createWORMTamperLogModel(prorm, tableName) {
+    const TamperLogModel = prorm.define('WORMTamperLog', {
+        id: {
+            type: data_types_1.DataTypes.INTEGER(),
+            primaryKey: true,
+            autoIncrement: true,
+        },
+        recordId: {
+            type: data_types_1.DataTypes.STRING(),
+            allowNull: false,
+        },
+        tableName: {
+            type: data_types_1.DataTypes.STRING(),
+            allowNull: false,
+        },
+        operation: {
+            type: data_types_1.DataTypes.ENUM('create', 'archive', 'freeze', 'unfreeze', 'tamper_detected'),
+            allowNull: false,
+        },
+        hash: {
+            type: data_types_1.DataTypes.STRING(64),
+            allowNull: false,
+        },
+        previousHash: {
+            type: data_types_1.DataTypes.STRING(64),
+            allowNull: true,
+        },
+        performedBy: {
+            type: data_types_1.DataTypes.STRING(),
+            allowNull: true,
+        },
+        metadata: {
+            type: data_types_1.DataTypes.JSON(),
+            allowNull: true,
+        },
+    }, {
+        tableName: `${tableName}_tamper_logs`,
+        timestamps: true,
+        indexes: [
+            { fields: ['recordId', 'tableName'] },
+            { fields: ['hash'] },
+            { fields: ['timestamp'] },
+        ],
+    });
+    return TamperLogModel;
+}
+// ==================== Decorator ====================
+/**
+ * Decorator to mark a model for WORM storage.
+ *
+ *   @WORM({ retentionPeriod: { years: 7 }, tamperEvident: true })
+ *   class FinancialRecord extends Model { ... }
+ */
+function WORM(options) {
+    return function (target) {
+        target[WORM_OPTIONS_KEY] = options;
+    };
+}
+/**
+ * Get the WORM options for a model.
+ */
+function getWORMOptions(Model) {
+    return Model[WORM_OPTIONS_KEY];
+}
+// ==================== WORMStorage Class ====================
+class WORMStorage {
+    /**
+     * Enable WORM storage on a model.
+     * Creates necessary metadata tables and registers hooks.
+     *
+     * @param model     - The model class to protect
+     * @param prorm - The Prorm instance
+     * @param options   - WORM configuration options
+     */
+    static enable(model, prorm, options) {
+        const metadataTableName = options.tableName ?? 'WORMMetadata';
+        const stateField = options.stateField ?? 'wormState';
+        const timestampField = options.timestampField ?? 'archivedAt';
+        const metadataModel = createWORMMetadataModel(prorm, metadataTableName, stateField);
+        const tamperLogModel = createWORMTamperLogModel(prorm, metadataTableName);
+        const config = {
+            model,
+            prorm,
+            options: {
+                retentionPeriod: options.retentionPeriod,
+                tamperEvident: options.tamperEvident ?? true,
+                tableName: metadataTableName,
+                stateField,
+                timestampField,
+                allowSoftDelete: options.allowSoftDelete ?? false,
+                autoArchive: options.autoArchive ?? false,
+                autoFreeze: options.autoFreeze ?? false,
+                integrateWithRetention: options.integrateWithRetention ?? true,
+            },
+            metadataModel,
+            tamperLogModel,
+        };
+        wormRegistry.set(model, config);
+        // Apply hooks
+        this.applyHooks(model, config);
+        // Integrate with DataRetentionPolicy if enabled
+        if (config.options.integrateWithRetention) {
+            data_retention_1.DataRetentionPolicy.set(model, {
+                maxAge: config.options.retentionPeriod,
+                field: timestampField,
+                onExpiry: 'delete',
+            });
+        }
+    }
+    /**
+     * Apply hooks to a model for WORM protection.
+     * Called automatically by enable().
+     *
+     * @param model  - The model class
+     * @param config - The WORM configuration
+     */
+    static applyHooks(model, config) {
+        const cfg = config ?? wormRegistry.get(model);
+        if (!cfg) {
+            throw new Error(`[WORMStorage] No WORM configuration found for model "${model.name ?? model}". ` +
+                `Call WORMStorage.enable(Model, prorm, options) first.`);
+        }
+        const { metadataModel, tamperLogModel, options } = cfg;
+        const hookName = 'orm:wormStorage';
+        // beforeCreate hook - initialize WORM metadata
+        model.addHook('beforeCreate', hookName, async function (record) {
+            const tableName = model.tableName ?? model.name;
+            // Create metadata entry
+            await metadataModel.create({
+                recordId: record.id,
+                tableName,
+                state: 'active',
+            });
+            // Record tamper log if enabled
+            if (options.tamperEvident) {
+                const recordData = record.toJSON ? record.toJSON() : record.dataValues;
+                const hash = computeHash(recordData);
+                await tamperLogModel.create({
+                    recordId: record.id,
+                    tableName,
+                    operation: 'create',
+                    hash,
+                    previousHash: '',
+                    metadata: { initialState: true },
+                });
+            }
+            // Auto-archive if enabled
+            if (options.autoArchive) {
+                const retentionUntil = data_retention_1.DataRetentionPolicy.cutoffDate(options.retentionPeriod);
+                await metadataModel.update({
+                    state: 'archived',
+                    archivedAt: new Date(),
+                    retentionUntil,
+                }, { where: { recordId: record.id, tableName } });
+            }
+        });
+        // beforeUpdate hook - block updates on archived/frozen records
+        model.addHook('beforeUpdate', hookName, async function (record) {
+            const tableName = model.tableName ?? model.name;
+            const metadata = await metadataModel.findOne({
+                where: { recordId: record.id, tableName },
+            });
+            if (metadata) {
+                const state = metadata.state;
+                if (state === 'frozen') {
+                    throw new Error(`[WORMStorage] UPDATE is not allowed on frozen record "${record.id}" in table "${tableName}". ` +
+                        `This record is immutable for SEC 17a-4 compliance.`);
+                }
+                if (state === 'archived') {
+                    // Check if this is an archive operation
+                    const changedFields = Object.keys(record._changed ?? {});
+                    if (changedFields.length > 0 && !changedFields.includes(options.stateField)) {
+                        throw new Error(`[WORMStorage] UPDATE is not allowed on archived record "${record.id}" in table "${tableName}". ` +
+                            `Archive records are immutable. Use WORMStorage.freeze() to explicitly freeze, ` +
+                            `or create a new record instead.`);
+                    }
+                }
+                // Verify tamper integrity if enabled
+                if (options.tamperEvident) {
+                    const isValid = await WORMStorage.verifyIntegrity(record.id, tableName);
+                    if (!isValid) {
+                        throw new Error(`[WORMStorage] TAMPER DETECTED on record "${record.id}" in table "${tableName}". ` +
+                            `The record hash does not match the chain.`);
+                    }
+                }
+            }
+        });
+        // beforeDestroy hook - block deletes on archived/frozen records
+        model.addHook('beforeDestroy', hookName, async function (record, options) {
+            const tableName = model.tableName ?? model.name;
+            const metadata = await metadataModel.findOne({
+                where: { recordId: record.id, tableName },
+            });
+            if (metadata) {
+                const state = metadata.state;
+                if (options.force) {
+                    // Allow hard delete only if not archived/frozen
+                    if (state === 'frozen' || state === 'archived') {
+                        throw new Error(`[WORMStorage] DELETE is not allowed on ${state} record "${record.id}" in table "${tableName}". ` +
+                            `WORM storage prevents deletion of archived/frozen records for SEC 17a-4 compliance.`);
+                    }
+                }
+                else if (!options.force) {
+                    // Soft delete behavior
+                    if (options.allowSoftDelete) {
+                        // Allow soft delete but log it
+                        if (options.tamperEvident) {
+                            await tamperLogModel.create({
+                                recordId: record.id,
+                                tableName,
+                                operation: 'tamper_detected',
+                                hash: 'soft_delete_attempt',
+                                metadata: { reason: 'soft_delete_blocked', state },
+                            });
+                        }
+                    }
+                    else {
+                        throw new Error(`[WORMStorage] DELETE is not allowed on record "${record.id}" in table "${tableName}". ` +
+                            `This record is protected by WORM storage for compliance.`);
+                    }
+                }
+            }
+        });
+        // afterUpdate hook - track state changes
+        model.addHook('afterUpdate', hookName, async function (record) {
+            if (options.tamperEvident) {
+                const tableName = model.tableName ?? model.name;
+                const metadata = await metadataModel.findOne({
+                    where: { recordId: record.id, tableName },
+                });
+                if (metadata) {
+                    const previousData = record.previous();
+                    const currentData = record.toJSON ? record.toJSON() : record.dataValues;
+                    // Get last hash
+                    const lastLog = await tamperLogModel.findOne({
+                        where: { recordId: record.id, tableName },
+                        order: [['createdAt', 'DESC']],
+                    });
+                    const hash = computeHash(currentData, lastLog?.hash ?? '');
+                    await tamperLogModel.create({
+                        recordId: record.id,
+                        tableName,
+                        operation: 'create', // Treat update as new entry in chain
+                        hash,
+                        previousHash: lastLog?.hash ?? '',
+                        metadata: { previousState: previousData, currentState: currentData },
+                    });
+                }
+            }
+        });
+    }
+    /**
+     * Archive a record (moves to archived state).
+     * Archived records are read-only but can still be queried.
+     *
+     * @param record - The record instance to archive
+     */
+    static async archive(record) {
+        const model = record.constructor;
+        const config = wormRegistry.get(model);
+        if (!config) {
+            throw new Error(`[WORMStorage] No WORM configuration found for model "${model.name ?? model}". ` +
+                `Call WORMStorage.enable(Model, prorm, options) first.`);
+        }
+        const { metadataModel, tamperLogModel, options } = config;
+        const tableName = model.tableName ?? model.name;
+        const recordId = record.id;
+        // Get current state
+        const metadata = await metadataModel.findOne({
+            where: { recordId, tableName },
+        });
+        if (!metadata) {
+            throw new Error(`[WORMStorage] No WORM metadata found for record "${recordId}".`);
+        }
+        if (metadata.state === 'frozen') {
+            throw new Error(`[WORMStorage] Cannot archive frozen record "${recordId}". Frozen records cannot be modified.`);
+        }
+        if (metadata.state === 'archived') {
+            // Already archived, just return
+            return;
+        }
+        // Calculate retention until date
+        const retentionUntil = data_retention_1.DataRetentionPolicy.cutoffDate(options.retentionPeriod);
+        // Update state to archived
+        await metadataModel.update({
+            state: 'archived',
+            archivedAt: new Date(),
+            retentionUntil,
+        }, { where: { recordId, tableName } });
+        // Record tamper log
+        if (options.tamperEvident) {
+            const recordData = record.toJSON ? record.toJSON() : record.dataValues;
+            const lastLog = await tamperLogModel.findOne({
+                where: { recordId, tableName },
+                order: [['createdAt', 'DESC']],
+            });
+            // Chain this entry's hash off the previous entry so the hash itself
+            // (not just the previousHash pointer) is bound to the prior chain
+            // state - required for verifyIntegrity() to detect tampering.
+            const hash = computeHash(recordData, lastLog?.hash ?? '');
+            await tamperLogModel.create({
+                recordId,
+                tableName,
+                operation: 'archive',
+                hash,
+                previousHash: lastLog?.hash ?? '',
+                metadata: { archivedState: true, retentionUntil },
+            });
+        }
+    }
+    /**
+     * Freeze a record (fully immutable).
+     * Frozen records cannot be modified or deleted.
+     *
+     * @param record - The record instance to freeze
+     */
+    static async freeze(record) {
+        const model = record.constructor;
+        const config = wormRegistry.get(model);
+        if (!config) {
+            throw new Error(`[WORMStorage] No WORM configuration found for model "${model.name ?? model}". ` +
+                `Call WORMStorage.enable(Model, prorm, options) first.`);
+        }
+        const { metadataModel, tamperLogModel, options } = config;
+        const tableName = model.tableName ?? model.name;
+        const recordId = record.id;
+        // Get current state
+        const metadata = await metadataModel.findOne({
+            where: { recordId, tableName },
+        });
+        if (!metadata) {
+            throw new Error(`[WORMStorage] No WORM metadata found for record "${recordId}".`);
+        }
+        if (metadata.state === 'frozen') {
+            // Already frozen, just return
+            return;
+        }
+        // Update state to frozen
+        await metadataModel.update({
+            state: 'frozen',
+            frozenAt: new Date(),
+        }, { where: { recordId, tableName } });
+        // Record tamper log
+        if (options.tamperEvident) {
+            const recordData = record.toJSON ? record.toJSON() : record.dataValues;
+            const lastLog = await tamperLogModel.findOne({
+                where: { recordId, tableName },
+                order: [['createdAt', 'DESC']],
+            });
+            // Chain this entry's hash off the previous entry (see archive() for
+            // rationale).
+            const hash = computeHash(recordData, lastLog?.hash ?? '');
+            await tamperLogModel.create({
+                recordId,
+                tableName,
+                operation: 'freeze',
+                hash,
+                previousHash: lastLog?.hash ?? '',
+                metadata: { frozenState: true },
+            });
+        }
+    }
+    /**
+     * Get the tamper evidence log for a record.
+     *
+     * @param recordId  - The record ID
+     * @param tableName - The table name
+     */
+    static async getTamperLog(recordId, tableName) {
+        // Find the config for this table
+        let config;
+        for (const [, cfg] of wormRegistry) {
+            if ((cfg.model.tableName ?? cfg.model.name) === tableName) {
+                config = cfg;
+                break;
+            }
+        }
+        if (!config) {
+            throw new Error(`[WORMStorage] No WORM configuration found for table "${tableName}". ` +
+                `Call WORMStorage.enable(Model, prorm, options) first.`);
+        }
+        const { tamperLogModel } = config;
+        const logs = await tamperLogModel.findAll({
+            where: { recordId: String(recordId), tableName },
+            order: [['createdAt', 'ASC']],
+        });
+        return logs.map((log) => log.toJSON());
+    }
+    /**
+     * Verify the integrity of a record's tamper chain.
+     *
+     * @param recordId  - The record ID
+     * @param tableName - The table name
+     * @returns True if chain is valid, false if tampering detected
+     */
+    static async verifyIntegrity(recordId, tableName) {
+        // Find the config for this table
+        let config;
+        for (const [, cfg] of wormRegistry) {
+            if ((cfg.model.tableName ?? cfg.model.name) === tableName) {
+                config = cfg;
+                break;
+            }
+        }
+        if (!config) {
+            throw new Error(`[WORMStorage] No WORM configuration found for table "${tableName}". ` +
+                `Call WORMStorage.enable(Model, prorm, options) first.`);
+        }
+        const { tamperLogModel, model } = config;
+        // Get all tamper log entries
+        const allLogs = await tamperLogModel.findAll({
+            where: { recordId: String(recordId), tableName },
+            order: [['createdAt', 'ASC']],
+        });
+        if (allLogs.length === 0) {
+            // No logs yet, check if record exists
+            const record = await model.findByPk(recordId);
+            return !!record;
+        }
+        // 'tamper_detected' entries (e.g. blocked soft-delete attempts) are
+        // flags, not members of the create/archive/freeze/update hash chain -
+        // they don't carry a real previousHash, so exclude them from chain
+        // verification.
+        const logs = allLogs.filter((log) => log.operation !== 'tamper_detected');
+        if (logs.length === 0) {
+            const record = await model.findByPk(recordId);
+            return !!record;
+        }
+        // Verify hash chain linkage: each entry's previousHash must match the
+        // hash recorded by the entry immediately before it.
+        for (let i = 0; i < logs.length; i++) {
+            const log = logs[i];
+            const expectedPreviousHash = i > 0 ? logs[i - 1].hash : '';
+            if ((log.previousHash ?? '') !== expectedPreviousHash) {
+                // Chain is broken - tampering detected
+                return false;
+            }
+        }
+        // Get the actual record and verify its current data still matches the
+        // hash recorded for the most recent chain entry. This is what makes
+        // the check tamper-*evident*: if the record's persisted data has been
+        // altered outside of the WORM hooks (e.g. a direct DB edit bypassing
+        // this ORM), or if the stored hash itself was edited, the recomputed
+        // hash will no longer match and this returns false.
+        const record = await model.findByPk(recordId);
+        if (!record) {
+            return false;
+        }
+        const recordData = record.toJSON ? record.toJSON() : record.dataValues;
+        const lastLog = logs[logs.length - 1];
+        const recomputedHash = computeHash(recordData, lastLog.previousHash ?? '');
+        return recomputedHash === lastLog.hash;
+    }
+    /**
+     * Check if WORM is enabled on a model.
+     *
+     * @param model - The model class
+     */
+    static isWORMEnabled(model) {
+        return wormRegistry.has(model);
+    }
+    /**
+     * Get the WORM configuration for a model.
+     *
+     * @param model - The model class
+     */
+    static getConfig(model) {
+        const config = wormRegistry.get(model);
+        return config?.options;
+    }
+    /**
+     * Enforce retention policy on a model.
+     * This will delete or anonymize records that have exceeded their retention period.
+     *
+     * @param model     - The model class
+     * @param prorm - The Prorm instance
+     */
+    static async enforceRetention(model, prorm) {
+        const config = wormRegistry.get(model);
+        if (!config) {
+            throw new Error(`[WORMStorage] No WORM configuration found for model "${model.name ?? model}". ` +
+                `Call WORMStorage.enable(Model, prorm, options) first.`);
+        }
+        // Use DataRetentionPolicy to enforce retention
+        return data_retention_1.DataRetentionPolicy.purge(model, prorm);
+    }
+    /**
+     * Get the archive state of a record.
+     *
+     * @param recordId  - The record ID
+     * @param tableName - The table name
+     */
+    static async getState(recordId, tableName) {
+        // Find the config for this table
+        let config;
+        for (const [, cfg] of wormRegistry) {
+            if ((cfg.model.tableName ?? cfg.model.name) === tableName) {
+                config = cfg;
+                break;
+            }
+        }
+        if (!config) {
+            throw new Error(`[WORMStorage] No WORM configuration found for table "${tableName}". ` +
+                `Call WORMStorage.enable(Model, prorm, options) first.`);
+        }
+        const { metadataModel } = config;
+        const metadata = await metadataModel.findOne({
+            where: { recordId: String(recordId), tableName },
+        });
+        return metadata ? metadata.state : null;
+    }
+    /**
+     * Disable WORM storage for a model.
+     *
+     * @param model - The model class
+     */
+    static disable(model) {
+        const config = wormRegistry.get(model);
+        if (config) {
+            // Remove hooks
+            const hookName = 'orm:wormStorage';
+            if (typeof config.model.removeHook === 'function') {
+                config.model.removeHook(hookName);
+            }
+            // Remove from DataRetentionPolicy if integrated
+            if (config.options.integrateWithRetention) {
+                data_retention_1.DataRetentionPolicy.unset(model);
+            }
+            wormRegistry.delete(model);
+        }
+    }
+    /**
+     * Get the WORM metadata model for a model.
+     *
+     * @param model - The model class
+     */
+    static getMetadataModel(model) {
+        return wormRegistry.get(model)?.metadataModel;
+    }
+    /**
+     * Get the tamper log model for a model.
+     *
+     * @param model - The model class
+     */
+    static getTamperLogModel(model) {
+        return wormRegistry.get(model)?.tamperLogModel;
+    }
+    /**
+     * List all models with WORM storage enabled.
+     */
+    static listWORMModels() {
+        return Array.from(wormRegistry.entries()).map(([model, config]) => ({
+            modelName: model.name ?? String(model),
+            options: config.options,
+        }));
+    }
+}
+exports.WORMStorage = WORMStorage;
+// ==================== Utility Functions ====================
+/**
+ * Apply WORM hooks to a model (exported for convenience).
+ *
+ * @param model - The model class
+ */
+function applyWORMHooks(model) {
+    WORMStorage.applyHooks(model);
+}
+/**
+ * Check if a specific record is frozen.
+ *
+ * @param recordId  - The record ID
+ * @param tableName - The table name
+ */
+async function isFrozen(recordId, tableName) {
+    const state = await WORMStorage.getState(recordId, tableName);
+    return state === 'frozen';
+}
+/**
+ * Check if a specific record is archived.
+ *
+ * @param recordId  - The record ID
+ * @param tableName - The table name
+ */
+async function isArchived(recordId, tableName) {
+    const state = await WORMStorage.getState(recordId, tableName);
+    return state === 'archived';
+}