@forge/storage-data-recovery 2.0.0-next.0

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2025 Atlassian
+Permission is hereby granted to use this software in accordance with the terms 
+and conditions outlined in the Atlassian Developer Terms, which can be found 
+at the following URL:
+https://developer.atlassian.com/platform/marketplace/atlassian-developer-terms/
+By using this software, you agree to comply with these terms and conditions. 
+If you do not agree with these terms, you are not permitted to use this software.

package/README.md

@@ -0,0 +1,59 @@
+# Forge Storage Data Recovery
+
+Standalone Library for Forge Storage Data Recovery operations.
+
+## Usage
+
+```typescript
+import { WhereConditions } from '@forge/kvs';
+import { dataRecovery, StorageType, SnapshotNotFoundError } from '@forge/storage-data-recovery';
+
+// Query data from a storage snapshot
+const results = await dataRecovery('hot117987', 'kvs') // StorageType: 'kvs' | 'secret' | 'custom_entity'
+  .query()
+  .where('key', WhereConditions.beginsWith('value'))
+  .limit(10)
+  .cursor('...')
+  .getMany();
+
+// Results structure
+console.log(results.results); // Array of { key: string, value: T }
+console.log(results.nextCursor); // Optional cursor for pagination
+
+// Error handling
+try {
+  const data = await dataRecovery('nonexistent-snapshot', 'kvs')
+    .query()
+    .getMany();
+} catch (error) {
+  if (error instanceof SnapshotNotFoundError) {
+    console.log('Snapshot not found');
+  }
+}
+```
+
+## API
+
+### `dataRecovery(snapshotName: string, storageType: StorageType)`
+
+Creates a recovery instance for the specified snapshot and storage type.
+
+**Parameters:**
+- `snapshotName`: Name of the storage snapshot (e.g., 'hot117987')
+- `storageType`: Type of storage - `'kvs' | 'secret' | 'custom_entity'`
+
+**Returns:** `DataRecoveryImpl` instance with query capabilities
+
+### Query Methods
+
+- `.query()`: Start building a query
+- `.where(property, condition)`: Filter by key conditions (supports WhereConditions from @forge/kvs)
+- `.limit(number)`: Limit number of results
+- `.cursor(string)`: Set pagination cursor
+- `.getMany<T>()`: Execute query and return results
+
+### Error Types
+
+- `RecoveryException`: Base recovery error
+- `SnapshotNotFoundError`: Thrown when snapshot doesn't exist
+- `InvalidStorageTypeError`: Thrown for invalid storage types

package/out/__test__/global-data-recovery.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=global-data-recovery.test.d.ts.map

package/out/__test__/global-data-recovery.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-data-recovery.test.d.ts","sourceRoot":"","sources":["../../src/__test__/global-data-recovery.test.ts"],"names":[],"mappings":""}

package/out/__test__/global-data-recovery.test.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kvs_1 = require("@forge/kvs");
+const index_1 = require("../index");
+const storage_client_1 = require("../storage-client");
+const data_recovery_1 = require("../data-recovery");
+const types_1 = require("../types");
+function prepare(response, snapshotName, storageType) {
+    const apiClient = jest.fn().mockResolvedValueOnce(response);
+    const storageClient = new storage_client_1.StorageClient(apiClient);
+    const sut = new data_recovery_1.DataRecoveryImpl(storageClient, snapshotName, storageType);
+    return {
+        apiClient,
+        storageClient,
+        sut
+    };
+}
+describe('dataRecovery', () => {
+    const snapshotName = 'test-snapshot';
+    const traceId = 'trace-id';
+    it('should be defined', () => {
+        expect(index_1.dataRecovery).toBeDefined();
+    });
+    it('should return a data recovery instance', () => {
+        const dataRecoveryInstance = (0, index_1.dataRecovery)(snapshotName, types_1.StorageTypeKVS);
+        expect(dataRecoveryInstance).toBeDefined();
+    });
+    it('should throw an error if the storage type is invalid', () => {
+        expect(() => (0, index_1.dataRecovery)(snapshotName, 'invalid')).toThrow(index_1.InvalidStorageTypeError);
+    });
+    it('should return a data recovery instance with the correct storage type', () => {
+        const dataRecoveryInstance = (0, index_1.dataRecovery)(snapshotName, types_1.StorageTypeKVS);
+        expect(dataRecoveryInstance.query).toBeDefined();
+        expect(dataRecoveryInstance.query().where('key', kvs_1.WhereConditions.beginsWith('test')).getMany).toBeDefined();
+        expect(dataRecoveryInstance.query().cursor('test').getMany).toBeDefined();
+        expect(dataRecoveryInstance.query().limit(10).getMany).toBeDefined();
+    });
+    it('should make a REST call to the data recovery API', async () => {
+        const response = new Response(JSON.stringify({
+            cursor: 'third-page',
+            data: [
+                {
+                    key: 'foo',
+                    value: { foo: 'bar' },
+                    entityName: 'example',
+                    provider: 'custom_entity',
+                    createdAt: 1753852892506,
+                    updatedAt: 1753852902502
+                }
+            ]
+        }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response, snapshotName, types_1.StorageTypeCustomEntity);
+        const rs = await sut
+            .query()
+            .cursor('second-page')
+            .limit(1)
+            .where('key', kvs_1.WhereConditions.beginsWith('fo'))
+            .getMany();
+        expect(rs).toEqual({
+            results: [
+                {
+                    key: 'foo',
+                    value: { foo: 'bar' },
+                    entityName: 'example',
+                    provider: 'custom_entity',
+                    createdAt: 1753852892506,
+                    updatedAt: 1753852902502
+                }
+            ],
+            nextCursor: 'third-page'
+        });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/data-recovery/query', {
+            body: JSON.stringify({
+                snapshotName: snapshotName,
+                provider: types_1.StorageTypeCustomEntity,
+                limit: 1,
+                after: 'second-page',
+                where: [{ property: 'key', condition: 'BEGINS_WITH', values: ['fo'] }]
+            }),
+            headers: {
+                'content-type': 'application/json'
+            },
+            method: 'POST'
+        });
+    });
+    it('should throw a SnapshotNotFoundError if the snapshot is not found', async () => {
+        const response = new Response('not found', {
+            status: 404,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut } = prepare(response, snapshotName, types_1.StorageTypeCustomEntity);
+        const query = sut.query().cursor('second-page').limit(1).where('key', kvs_1.WhereConditions.beginsWith('fo'));
+        await expect(query.getMany()).rejects.toMatchObject(new index_1.SnapshotNotFoundError(snapshotName));
+    });
+});

package/out/data-recovery.d.ts

@@ -0,0 +1,23 @@
+import { WhereConditions } from '@forge/kvs';
+import { StorageClient } from './storage-client';
+import { ListResult, RecoveryQueryBuilder, StorageType } from './types';
+import { QueryOptions } from '@forge/kvs/out/interfaces/query';
+export declare class RecoveryQueryBuilderImpl implements RecoveryQueryBuilder {
+    private storageClient;
+    private snapshotName;
+    private storageType;
+    private options;
+    constructor(storageClient: StorageClient, snapshotName: string, storageType: StorageType, options?: QueryOptions);
+    where(property: 'key', condition: ReturnType<typeof WhereConditions.beginsWith>): this;
+    cursor(cursor: string): this;
+    limit(limit: number): this;
+    getMany<T>(): Promise<ListResult<T>>;
+}
+export declare class DataRecoveryImpl {
+    private storageClient;
+    private snapshotName;
+    private storageType;
+    constructor(storageClient: StorageClient, snapshotName: string, storageType: StorageType);
+    query(): RecoveryQueryBuilder;
+}
+//# sourceMappingURL=data-recovery.d.ts.map

package/out/data-recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-recovery.d.ts","sourceRoot":"","sources":["../src/data-recovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAE/D,qBAAa,wBAAyB,YAAW,oBAAoB;IAEjE,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,OAAO;gBAHP,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,YAAiB;IAGpC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,UAAU,CAAC,GAAG,IAAI;IAKtF,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK5B,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKpB,OAAO,CAAC,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;CAS3C;AAED,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,WAAW;gBAFX,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW;IAGlC,KAAK,IAAI,oBAAoB;CAG9B"}

package/out/data-recovery.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataRecoveryImpl = exports.RecoveryQueryBuilderImpl = void 0;
+class RecoveryQueryBuilderImpl {
+    storageClient;
+    snapshotName;
+    storageType;
+    options;
+    constructor(storageClient, snapshotName, storageType, options = {}) {
+        this.storageClient = storageClient;
+        this.snapshotName = snapshotName;
+        this.storageType = storageType;
+        this.options = options;
+    }
+    where(property, condition) {
+        this.options.where = [{ property, ...condition }];
+        return this;
+    }
+    cursor(cursor) {
+        this.options.cursor = cursor;
+        return this;
+    }
+    limit(limit) {
+        this.options.limit = limit;
+        return this;
+    }
+    async getMany() {
+        return await this.storageClient.query({
+            snapshotName: this.snapshotName,
+            provider: this.storageType,
+            limit: this.options.limit,
+            after: this.options.cursor,
+            where: this.options.where
+        });
+    }
+}
+exports.RecoveryQueryBuilderImpl = RecoveryQueryBuilderImpl;
+class DataRecoveryImpl {
+    storageClient;
+    snapshotName;
+    storageType;
+    constructor(storageClient, snapshotName, storageType) {
+        this.storageClient = storageClient;
+        this.snapshotName = snapshotName;
+        this.storageType = storageType;
+    }
+    query() {
+        return new RecoveryQueryBuilderImpl(this.storageClient, this.snapshotName, this.storageType);
+    }
+}
+exports.DataRecoveryImpl = DataRecoveryImpl;

package/out/errors.d.ts

@@ -0,0 +1,11 @@
+export declare class RecoveryException extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export declare class SnapshotNotFoundError extends RecoveryException {
+    constructor(snapshotName: string);
+}
+export declare class InvalidStorageTypeError extends RecoveryException {
+    constructor(storageType: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/out/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,iBAAkB,SAAQ,KAAK;aAGxB,IAAI,CAAC;gBADrB,OAAO,EAAE,MAAM,EACC,IAAI,CAAC,oBAAQ;CAKhC;AAED,qBAAa,qBAAsB,SAAQ,iBAAiB;gBAC9C,YAAY,EAAE,MAAM;CAIjC;AAED,qBAAa,uBAAwB,SAAQ,iBAAiB;gBAChD,WAAW,EAAE,MAAM;CAIhC"}

package/out/errors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidStorageTypeError = exports.SnapshotNotFoundError = exports.RecoveryException = void 0;
+class RecoveryException extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'RecoveryException';
+    }
+}
+exports.RecoveryException = RecoveryException;
+class SnapshotNotFoundError extends RecoveryException {
+    constructor(snapshotName) {
+        super(`Snapshot '${snapshotName}' not found`, 'SNAPSHOT_NOT_FOUND');
+        this.name = 'SnapshotNotFoundError';
+    }
+}
+exports.SnapshotNotFoundError = SnapshotNotFoundError;
+class InvalidStorageTypeError extends RecoveryException {
+    constructor(storageType) {
+        super(`Invalid storage type '${storageType}'`, 'INVALID_STORAGE_TYPE');
+        this.name = 'InvalidStorageTypeError';
+    }
+}
+exports.InvalidStorageTypeError = InvalidStorageTypeError;

package/out/index.d.ts

@@ -0,0 +1,7 @@
+import { DataRecoveryImpl } from './data-recovery';
+import { StorageType } from './types';
+declare function dataRecovery(snapshotName: string, storageType: StorageType): DataRecoveryImpl;
+export * from './errors';
+export * from './types';
+export { dataRecovery };
+//# sourceMappingURL=index.d.ts.map

package/out/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,EAAE,WAAW,EAA8D,MAAM,SAAS,CAAC;AA6ClG,iBAAS,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,oBAMnE;AAED,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/out/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataRecovery = void 0;
+const tslib_1 = require("tslib");
+const data_recovery_1 = require("./data-recovery");
+const errors_1 = require("./errors");
+const storage_client_1 = require("./storage-client");
+const types_1 = require("./types");
+async function fetchDirectlyToKVS(path, options) {
+    const runtime = global.__forge_runtime__;
+    if (!runtime) {
+        throw new Error('Forge runtime not found');
+    }
+    const { proxy, kvs, tracing } = runtime;
+    return await global.__forge_fetch__({ type: 'kvs' }, path, {
+        ...options,
+        headers: {
+            ...options?.headers,
+            Authorization: `Bearer ${proxy.token}`,
+            Host: kvs?.host,
+            'x-b3-traceid': tracing.traceId,
+            'x-b3-spanid': tracing.spanId
+        }
+    });
+}
+async function fetchViaFPP(path, options) {
+    return await global.__forge_fetch__({
+        type: 'kvs',
+        provider: 'app',
+        remote: 'kvs'
+    }, path, options);
+}
+function buildFetchClient() {
+    const runtime = global.__forge_runtime__;
+    if (runtime?.kvs?.url && runtime?.kvs?.host) {
+        return fetchDirectlyToKVS;
+    }
+    return fetchViaFPP;
+}
+function dataRecovery(snapshotName, storageType) {
+    if (![types_1.StorageTypeKVS, types_1.StorageTypeSecret, types_1.StorageTypeCustomEntity].includes(storageType)) {
+        throw new errors_1.InvalidStorageTypeError(storageType);
+    }
+    return new data_recovery_1.DataRecoveryImpl(new storage_client_1.StorageClient(buildFetchClient()), snapshotName, storageType);
+}
+exports.dataRecovery = dataRecovery;
+tslib_1.__exportStar(require("./errors"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/out/storage-client.d.ts

@@ -0,0 +1,9 @@
+import { FetchMethod } from '@forge/api';
+import { ListResult, QueryRequest } from './types';
+export declare class StorageClient {
+    private apiClient;
+    constructor(apiClient: FetchMethod);
+    query<T>(body: QueryRequest): Promise<ListResult<T>>;
+    private request;
+}
+//# sourceMappingURL=storage-client.d.ts.map

package/out/storage-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-client.d.ts","sourceRoot":"","sources":["../src/storage-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAiB,MAAM,SAAS,CAAC;AAGlE,qBAAa,aAAa;IACZ,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,WAAW;IAEpC,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAQ5C,OAAO;CAsBtB"}

package/out/storage-client.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageClient = void 0;
+const kvs_1 = require("@forge/kvs");
+const errors_1 = require("./errors");
+class StorageClient {
+    apiClient;
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async query(body) {
+        const rs = await this.request(`/api/v1/data-recovery/query`, body);
+        return {
+            results: rs.data,
+            nextCursor: rs.cursor
+        };
+    }
+    async request(path, body) {
+        const requestBody = {
+            method: 'POST',
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json'
+            }
+        };
+        const response = await this.apiClient(path, requestBody);
+        const responseText = await response.text();
+        if (response.status === 404) {
+            throw new errors_1.SnapshotNotFoundError(body.snapshotName);
+        }
+        try {
+            return JSON.parse(responseText);
+        }
+        catch (error) {
+            throw new kvs_1.ForgeKvsError(`Unexpected error. Response was not valid JSON: ${responseText}`);
+        }
+    }
+}
+exports.StorageClient = StorageClient;

package/out/types.d.ts

@@ -0,0 +1,40 @@
+import { WhereConditions } from '@forge/kvs';
+export declare type QueryWhere = {
+    condition: 'BEGINS_WITH';
+    property: 'key';
+    values: Array<unknown>;
+};
+export declare type QueryRequest = {
+    snapshotName: string;
+    provider: StorageType;
+    limit?: number;
+    after?: string;
+    where?: Array<QueryWhere>;
+};
+export declare type QueryResponse<T> = {
+    data: Array<DataRecoverySchema<T>>;
+    cursor?: string;
+};
+export declare type DataRecoverySchema<T> = {
+    key: string;
+    value: T;
+    entityName?: string;
+    provider: 'kvs' | 'secret' | 'custom_entity';
+    createdAt: number;
+    updatedAt: number;
+};
+export declare const StorageTypeKVS = "kvs";
+export declare const StorageTypeSecret = "secret";
+export declare const StorageTypeCustomEntity = "custom_entity";
+export declare type StorageType = 'kvs' | 'secret' | 'custom_entity';
+export interface ListResult<T> {
+    results: DataRecoverySchema<T>[];
+    nextCursor?: string;
+}
+export interface RecoveryQueryBuilder {
+    where(property: 'key', condition: ReturnType<typeof WhereConditions.beginsWith>): RecoveryQueryBuilder;
+    cursor(cursor: string): RecoveryQueryBuilder;
+    limit(limit: number): RecoveryQueryBuilder;
+    getMany<T>(): Promise<ListResult<T>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/out/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,oBAAY,UAAU,GAAG;IACvB,SAAS,EAAE,aAAa,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC;IAChB,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACxB,CAAC;AAEF,oBAAY,YAAY,GAAG;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC3B,CAAC;AAEF,oBAAY,aAAa,CAAC,CAAC,IAAI;IAC7B,IAAI,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,oBAAY,kBAAkB,CAAC,CAAC,IAAI;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,CAAC,CAAC;IACT,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,eAAe,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,cAAc,QAAQ,CAAC;AACpC,eAAO,MAAM,iBAAiB,WAAW,CAAC;AAC1C,eAAO,MAAM,uBAAuB,kBAAkB,CAAC;AAEvD,oBAAY,WAAW,GAAG,KAAK,GAAG,QAAQ,GAAG,eAAe,CAAC;AAE7D,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,UAAU,CAAC,GAAG,oBAAoB,CAAC;IACvG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,CAAC;IAC7C,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,CAAC;IAC3C,OAAO,CAAC,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;CACtC"}

package/out/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageTypeCustomEntity = exports.StorageTypeSecret = exports.StorageTypeKVS = void 0;
+exports.StorageTypeKVS = 'kvs';
+exports.StorageTypeSecret = 'secret';
+exports.StorageTypeCustomEntity = 'custom_entity';

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@forge/storage-data-recovery",
+  "version": "2.0.0-next.0",
+  "description": "Forge Storage Data Recovery SDK",
+  "author": "Atlassian",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "main": "out/index.js",
+  "types": "out/index.d.ts",
+  "files": [
+    "out"
+  ],
+  "scripts": {
+    "build": "yarn run clean && yarn run compile",
+    "clean": "rm -rf ./out && rm -f tsconfig.tsbuildinfo",
+    "compile": "tsc -b -v"
+  },
+  "devDependencies": {
+    "@types/node": "20.19.1"
+  },
+  "dependencies": {
+    "@forge/api": "6.1.5-next.1",
+    "@forge/kvs": "1.0.9-next.0"
+  },
+  "publishConfig": {
+    "registry": "https://packages.atlassian.com/api/npm/npm-public/"
+  }
+}