@nu-art/thunderstorm-shared 0.400.5

package/BaseHttpModule.d.ts

@@ -0,0 +1,28 @@
+import { ApiDef, TypedApi } from './types.js';
+import { Module } from '@nu-art/ts-common';
+import { BaseHttpRequest } from './BaseHttpRequest.js';
+import { HttpException } from './request-types.js';
+type HttpConfig = {
+    origin?: string;
+    timeout?: number;
+    compress?: boolean;
+};
+export declare abstract class BaseHttpModule_Class<Config extends HttpConfig = HttpConfig> extends Module<Config> {
+    protected origin: string;
+    protected timeout: number;
+    private readonly defaultHeaders;
+    protected defaultOnComplete?: (response: unknown, input: unknown, request: BaseHttpRequest<any>) => Promise<any>;
+    protected defaultOnError?: (errorResponse: HttpException, input: unknown, request: BaseHttpRequest<any>) => Promise<any>;
+    constructor();
+    init(): void;
+    getOrigin(): string;
+    shouldCompress(): boolean | undefined;
+    setDefaultOnComplete: (defaultOnComplete: (response: unknown, input: unknown, request: BaseHttpRequest<any>) => Promise<any>) => void;
+    setDefaultOnError: (defaultOnError: (errorResponse: HttpException, input: unknown, request: BaseHttpRequest<any>) => Promise<any>) => void;
+    addDefaultHeader(key: string, header: (() => string | string[]) | string | string[]): void;
+    getDefaultHeaders(): {
+        [k: string]: string | string[];
+    };
+    abstract createRequest<API extends TypedApi<any, any, any, any>>(apiDef: ApiDef<API>, data?: any): BaseHttpRequest<API>;
+}
+export {};

package/BaseHttpModule.js

@@ -0,0 +1,56 @@
+import { BadImplementationException, Module, } from '@nu-art/ts-common';
+export class BaseHttpModule_Class extends Module {
+    origin;
+    timeout = 10000;
+    defaultHeaders = {};
+    defaultOnComplete;
+    defaultOnError;
+    constructor() {
+        super();
+        this.setDefaultConfig({ compress: true });
+    }
+    init() {
+        this.timeout = this.config.timeout || this.timeout;
+    }
+    getOrigin() {
+        return this.origin;
+    }
+    shouldCompress() {
+        return this.config.compress;
+    }
+    setDefaultOnComplete = (defaultOnComplete) => {
+        this.defaultOnComplete = defaultOnComplete;
+    };
+    setDefaultOnError = (defaultOnError) => {
+        this.defaultOnError = defaultOnError;
+    };
+    addDefaultHeader(key, header) {
+        this.defaultHeaders[key] = header;
+    }
+    getDefaultHeaders() {
+        return Object.keys(this.defaultHeaders).reduce((toRet, _key) => {
+            const defaultHeader = this.defaultHeaders[_key];
+            switch (typeof defaultHeader) {
+                case 'string':
+                    toRet[_key] = [defaultHeader];
+                    break;
+                case 'function':
+                    toRet[_key] = defaultHeader();
+                    break;
+                case 'object':
+                    if (Array.isArray(defaultHeader)) {
+                        toRet[_key] = defaultHeader;
+                        break;
+                    }
+                // eslint-disable-next-line no-fallthrough
+                case 'boolean':
+                case 'number':
+                case 'symbol':
+                case 'bigint':
+                case 'undefined':
+                    throw new BadImplementationException(`Headers values can only be of type: (() => string | string[]) | string | string[], got type ${typeof defaultHeader} `);
+            }
+            return toRet;
+        }, {});
+    }
+}

package/BaseHttpRequest.d.ts

@@ -0,0 +1,70 @@
+import { Logger } from '@nu-art/ts-common';
+import { HttpMethod, TypedApi } from './types.js';
+import { HttpException, TS_Progress } from './request-types.js';
+import { ApiErrorResponse } from '@nu-art/ts-common/core/exceptions/types';
+export declare abstract class BaseHttpRequest<API extends TypedApi<any, any, any, any>> {
+    key: string;
+    requestData: any;
+    protected origin?: string;
+    protected headers: {
+        [s: string]: string[];
+    };
+    protected method: HttpMethod;
+    protected timeout: number;
+    protected body: API['B'];
+    protected url: string;
+    protected params: {
+        [K in keyof API['P']]?: API['P'][K];
+    };
+    protected responseType: string;
+    protected label: string;
+    protected onProgressListener: (ev: TS_Progress) => void;
+    protected aborted: boolean;
+    protected compress: boolean;
+    protected logger?: Logger;
+    private onCompleted?;
+    private onError?;
+    constructor(requestKey: string, requestData?: any);
+    resolveTypedException(exception: HttpException<any> | unknown): API['E'] | undefined;
+    setLogger(logger?: Logger): this;
+    getRequestData(): any;
+    setOrigin(origin?: string): this;
+    setOnProgressListener(onProgressListener: (ev: TS_Progress) => void): this;
+    setLabel(label: string): this;
+    setMethod(method: HttpMethod): this;
+    setResponseType(responseType: string): this;
+    setUrlParams(params: API['P']): this;
+    setUrlParam<K extends keyof API['P'] = keyof API['P']>(key: K, value: API['P'][K]): this;
+    setUrl(url: string): this;
+    getUrl(): string;
+    setRelativeUrl(relativeUrl: string): this;
+    setTimeout(timeout: number): this;
+    setHeaders(headers: {
+        [s: string]: string | string[];
+    }): this;
+    addHeaders(headers: {
+        [s: string]: string | string[];
+    }): this;
+    setHeader(_key: string, value: string | string[]): this;
+    addHeader(_key: string, value: string | string[]): this;
+    removeHeader(key: string): this;
+    protected _addHeaderImpl(key: string, value: string | string[]): this;
+    protected prepareJsonBody(bodyObject: API['B']): any;
+    setBodyAsJson(bodyObject: API['B'], compress?: boolean): this;
+    setBody(bodyAsString: any, _compress?: boolean): this;
+    isValidStatus(statusCode: number): boolean;
+    protected print(): void;
+    executeSync(print?: boolean): Promise<API['R']>;
+    execute(onSuccess?: (response: API['R'], data?: string) => Promise<void> | void, onError?: (reason: HttpException<API['E']>) => any): this;
+    clearOnCompleted: () => void;
+    setOnCompleted: (onCompleted?: (response: API["R"], input: API["P"] | API["B"], request: BaseHttpRequest<API>) => Promise<any>) => this;
+    setOnError(onError?: (errorResponse: HttpException<API['E']>, input: API['P'] | API['B'], request: BaseHttpRequest<API>) => Promise<any>): this;
+    protected abstract getResponse(): API['R'];
+    abstract getErrorResponse(): ApiErrorResponse<API['E']>;
+    protected abstract abortImpl(): void;
+    abstract getStatus(): number;
+    getResponseHeader(headerKey: string): string | string[] | undefined;
+    abstract _getResponseHeader(headerKey: string): string | string[] | undefined;
+    abort(): void;
+    protected abstract executeImpl(): Promise<void>;
+}

package/BaseHttpRequest.js

@@ -0,0 +1,261 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * 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.
+ */
+import { __stringify, _keys, asArray, BadImplementationException, exists, isErrorOfType, MimeType_json, Minute, ModuleManager } from '@nu-art/ts-common';
+import { HttpMethod } from './types.js';
+import { HttpException } from './request-types.js';
+import { dispatcher_onAuthRequired } from './no-auth-listener.js';
+import { DefaultHttpServerConfig } from './consts.js';
+import { HttpCodes } from '@nu-art/ts-common/core/exceptions/http-codes';
+export class BaseHttpRequest {
+    key;
+    requestData;
+    origin;
+    headers = {};
+    method = HttpMethod.GET;
+    timeout = 10000;
+    body;
+    url;
+    params = {};
+    responseType;
+    label;
+    onProgressListener;
+    aborted = false;
+    compress;
+    logger;
+    onCompleted;
+    onError;
+    constructor(requestKey, requestData) {
+        this.key = requestKey;
+        this.requestData = requestData;
+        this.label = `http request: ${requestKey}${requestData ? ` ${requestData}` : ''}`;
+        this.compress = false;
+        // @ts-ignore
+        if (ModuleManager.instance.config.isDebug)
+            this.timeout = 5 * Minute;
+    }
+    resolveTypedException(exception) {
+        if (isErrorOfType(exception, HttpException))
+            return exception.errorResponse?.error;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+        return this;
+    }
+    getRequestData() {
+        return this.requestData;
+    }
+    setOrigin(origin) {
+        this.origin = origin;
+        return this;
+    }
+    setOnProgressListener(onProgressListener) {
+        this.onProgressListener = onProgressListener;
+        return this;
+    }
+    setLabel(label) {
+        this.label = label;
+        return this;
+    }
+    setMethod(method) {
+        this.method = method;
+        return this;
+    }
+    setResponseType(responseType) {
+        this.responseType = responseType;
+        return this;
+    }
+    setUrlParams(params) {
+        if (!params)
+            return this;
+        _keys(params).forEach((key) => {
+            const param = params[key];
+            return param && typeof param === 'string' && this.setUrlParam(key, param);
+        });
+        return this;
+    }
+    setUrlParam(key, value) {
+        delete this.params[key];
+        this.params[key] = value;
+        return this;
+    }
+    setUrl(url) {
+        this.url = url;
+        return this;
+    }
+    getUrl() {
+        return this.url;
+    }
+    setRelativeUrl(relativeUrl) {
+        if (!this.origin)
+            throw new BadImplementationException('if you want to use relative urls, you need to set an origin');
+        if (relativeUrl.startsWith('/'))
+            relativeUrl = relativeUrl.substring(1);
+        this.url = `${this.origin}/${relativeUrl}`;
+        return this;
+    }
+    setTimeout(timeout) {
+        // console.log(`${this.url} - setting timeout: ${timeout}`);
+        this.timeout = timeout;
+        return this;
+    }
+    setHeaders(headers) {
+        if (!headers)
+            return this;
+        Object.keys(headers).forEach((key) => this.setHeader(key, headers[key]));
+        return this;
+    }
+    addHeaders(headers) {
+        if (!headers)
+            return this;
+        Object.keys(headers).forEach((key) => this.addHeader(key, headers[key]));
+        return this;
+    }
+    setHeader(_key, value) {
+        const key = _key.toLowerCase();
+        delete this.headers[key];
+        return this.addHeader(key, value);
+    }
+    addHeader(_key, value) {
+        const key = _key.toLowerCase();
+        return this._addHeaderImpl(key, value);
+    }
+    removeHeader(key) {
+        delete this.headers[key];
+        return this;
+    }
+    _addHeaderImpl(key, value) {
+        const values = asArray(value);
+        if (!this.headers[key])
+            this.headers[key] = values;
+        else
+            this.headers[key].push(...values);
+        return this;
+    }
+    prepareJsonBody(bodyObject) {
+        return bodyObject;
+    }
+    setBodyAsJson(bodyObject, compress) {
+        this.setHeader('content-type', MimeType_json);
+        this.setBody(this.prepareJsonBody(bodyObject), compress);
+        return this;
+    }
+    setBody(bodyAsString, _compress) {
+        this.body = bodyAsString;
+        this.compress = _compress === undefined ? this.compress : _compress;
+        if (typeof bodyAsString === 'string' && this.compress)
+            this.setHeader('Content-encoding', 'gzip');
+        return this;
+    }
+    isValidStatus(statusCode) {
+        return statusCode >= 200 && statusCode < 300;
+    }
+    print() {
+        this.logger?.logWarning(`Url: ${this.url}`);
+        this.logger?.logWarning(`Params:`, this.params);
+        this.logger?.logWarning(`Headers:`, this.headers);
+    }
+    async executeSync(print = false) {
+        if (print)
+            this.print();
+        await this.executeImpl();
+        const status = this.getStatus();
+        const requestData = this.body || this.params;
+        if (this.aborted) {
+            const httpException = new HttpException(status, this.url); // should be status 0
+            await this.onError?.(httpException, requestData, this);
+            throw httpException;
+        }
+        if (!this.isValidStatus(status)) {
+            const errorResponse = this.getErrorResponse();
+            const httpException = new HttpException(status, this.url, errorResponse);
+            if (status === HttpCodes._4XX.UNAUTHORIZED.code)
+                await dispatcher_onAuthRequired.dispatchModuleAsync(this);
+            await this.onError?.(httpException, requestData, this);
+            throw httpException;
+        }
+        let response = this.getResponse();
+        if (!exists(response)) {
+            await this.onCompleted?.(response, requestData, this);
+            return response;
+        }
+        try {
+            response = JSON.parse(response);
+        }
+        catch (ignore) {
+            //
+        }
+        await this.onCompleted?.(response, requestData, this);
+        return response;
+    }
+    execute(onSuccess = () => this.logger?.logVerbose(`Completed: ${this.label}`), onError = reason => this.logger?.logWarning(`Error: ${this.label}`, reason)) {
+        this.executeSync()
+            .then(onSuccess)
+            .catch(onError);
+        return this;
+    }
+    clearOnCompleted = () => {
+        delete this.onCompleted;
+    };
+    setOnCompleted = (onCompleted) => {
+        if (!onCompleted)
+            return this;
+        if (this.onCompleted && onCompleted) {
+            const _onCompleted = this.onCompleted;
+            this.onCompleted = async (response, input, request) => {
+                await _onCompleted(response, input, request);
+                await onCompleted(response, input, request);
+            };
+        }
+        else
+            this.onCompleted = async (response, input, request) => {
+                await onCompleted?.(response, input, request);
+            };
+        return this;
+    };
+    setOnError(onError) {
+        if (!onError)
+            return this;
+        if (this.onError && onError) {
+            const _onError = this.onError;
+            this.onError = async (response, input, request) => {
+                await _onError(response, input, request);
+                await onError(response, input, request);
+            };
+        }
+        else
+            this.onError = async (response, input, request) => {
+                await onError?.(response, input, request);
+            };
+        return this;
+    }
+    getResponseHeader(headerKey) {
+        try {
+            return this._getResponseHeader(headerKey);
+        }
+        catch (e) {
+            this.logger?.logError(`Need to add responseHeaders to backend config: ${__stringify(DefaultHttpServerConfig, true)}`, e);
+        }
+    }
+    abort() {
+        this.aborted = true;
+        this.abortImpl();
+    }
+}

package/_entity/app-config/api-def.d.ts

@@ -0,0 +1,10 @@
+import { ApiDefResolver, QueryApi } from '../../types.js';
+export type RequestBody_GetResolverByKey = {
+    key: string;
+};
+export type ApiStruct_AppConfig = {
+    _v1: {
+        getConfigByKey: QueryApi<any, RequestBody_GetResolverByKey>;
+    };
+};
+export declare const ApiDef_AppConfig: ApiDefResolver<ApiStruct_AppConfig>;

package/_entity/app-config/api-def.js

@@ -0,0 +1,6 @@
+import { HttpMethod } from '../../types.js';
+export const ApiDef_AppConfig = {
+    _v1: {
+        getConfigByKey: { method: HttpMethod.GET, path: 'v1/app-config/get-resolver-data-by-key' },
+    }
+};

package/_entity/app-config/db-def.d.ts

@@ -0,0 +1,3 @@
+import { DBDef_V3 } from '@nu-art/ts-common';
+import { DBProto_AppConfig } from './types.js';
+export declare const DBDef_AppConfig: DBDef_V3<DBProto_AppConfig>;

package/_entity/app-config/db-def.js

@@ -0,0 +1,20 @@
+import { tsValidateMustExist, tsValidateString } from '@nu-art/ts-common';
+const Validator_ModifiableProps = {
+    key: tsValidateString(),
+    data: tsValidateMustExist,
+};
+const Validator_GeneratedProps = {};
+export const DBDef_AppConfig = {
+    modifiablePropsValidator: Validator_ModifiableProps,
+    generatedPropsValidator: Validator_GeneratedProps,
+    versions: ['1.0.0'],
+    dbKey: 'app-configs',
+    entityName: 'AppConfig',
+    frontend: {
+        group: 'app',
+        name: 'config'
+    },
+    backend: {
+        name: 'app-configs'
+    }
+};

package/_entity/app-config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './db-def.js';
+export * from './api-def.js';

package/_entity/app-config/index.js

@@ -0,0 +1,4 @@
+// Generated DB Item type: AppConfig
+export * from './types.js';
+export * from './db-def.js';
+export * from './api-def.js';

package/_entity/app-config/types.d.ts

@@ -0,0 +1,16 @@
+import { DB_Object, DBProto, Proto_DB_Object, VersionsDeclaration } from '@nu-art/ts-common';
+type VersionTypes_AppConfig = {
+    '1.0.0': DB_AppConfig;
+};
+type Versions = VersionsDeclaration<['1.0.0'], VersionTypes_AppConfig>;
+type Dependencies = {};
+type UniqueKeys = '_id';
+type GeneratedProps = never;
+type Proto<D> = Proto_DB_Object<DB_AppConfig<D>, 'app-configs', GeneratedProps, Versions, UniqueKeys, Dependencies>;
+export type DBProto_AppConfig<D = any> = DBProto<Proto<D>>;
+export type UI_AppConfig = DBProto_AppConfig['uiType'];
+export type DB_AppConfig<D = any> = DB_Object & {
+    key: string;
+    data: D;
+};
+export {};

package/_entity/app-config/types.js

@@ -0,0 +1 @@
+export {};

package/_entity/backup-doc/api-def.d.ts

@@ -0,0 +1,17 @@
+import { ApiDefResolver, QueryApi } from '../../types.js';
+import { FetchBackupDoc } from './types.js';
+export type Request_BackupId = {
+    backupId: string;
+};
+export type Response_BackupDocs = {
+    backupInfo: FetchBackupDoc;
+};
+export type ApiStruct_BackupDoc = {
+    _v1: {
+        initiateBackup: QueryApi<{
+            pathToBackup: string;
+        } | undefined>;
+        fetchBackupDocs: QueryApi<Response_BackupDocs, Request_BackupId>;
+    };
+};
+export declare const ApiDef_BackupDoc: ApiDefResolver<ApiStruct_BackupDoc>;

package/_entity/backup-doc/api-def.js

@@ -0,0 +1,7 @@
+import { HttpMethod } from '../../types.js';
+export const ApiDef_BackupDoc = {
+    _v1: {
+        initiateBackup: { method: HttpMethod.GET, path: 'v1/initiate-backup-v2' },
+        fetchBackupDocs: { method: HttpMethod.GET, path: 'v1/fetch-backup-docs-v2' },
+    }
+};

package/_entity/backup-doc/db-def.d.ts

@@ -0,0 +1,3 @@
+import { DBDef_V3 } from '@nu-art/ts-common';
+import { DBProto_BackupDoc } from './types.js';
+export declare const DBDef_BackupDoc: DBDef_V3<DBProto_BackupDoc>;

package/_entity/backup-doc/db-def.js

@@ -0,0 +1,30 @@
+import { tsValidateArray, tsValidateNumber, tsValidateString, tsValidateTimestamp } from '@nu-art/ts-common';
+const Validator_ModifiableProps = {
+    timestamp: tsValidateTimestamp(),
+    backupPath: tsValidateString(),
+    firebasePath: tsValidateString(),
+    metadataPath: tsValidateString(),
+    metadata: {
+        timestamp: tsValidateTimestamp(),
+        collectionsData: tsValidateArray({
+            dbKey: tsValidateString(),
+            numOfDocs: tsValidateNumber(),
+            version: tsValidateString()
+        })
+    }
+};
+const Validator_GeneratedProps = {};
+export const DBDef_BackupDoc = {
+    modifiablePropsValidator: Validator_ModifiableProps,
+    generatedPropsValidator: Validator_GeneratedProps,
+    versions: ['1.0.0'],
+    dbKey: 'firestore-backup-status-v2',
+    entityName: 'firestoreBackupStatus',
+    frontend: {
+        group: 'app',
+        name: 'firestore-backup-status-v2'
+    },
+    backend: {
+        name: 'backup-doc'
+    }
+};

package/_entity/backup-doc/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './db-def.js';
+export * from './api-def.js';

package/_entity/backup-doc/index.js

@@ -0,0 +1,4 @@
+// Generated DB Item type: BackupDoc
+export * from './types.js';
+export * from './db-def.js';
+export * from './api-def.js';

package/_entity/backup-doc/types.d.ts

@@ -0,0 +1,45 @@
+import { DB_Object, DBProto, Proto_DB_Object, VersionsDeclaration } from '@nu-art/ts-common';
+type VersionTypes_BackupDoc = {
+    '1.0.0': DB_BackupDoc;
+};
+type Versions = VersionsDeclaration<['1.0.0'], VersionTypes_BackupDoc>;
+type Dependencies = {};
+type UniqueKeys = '_id';
+type GeneratedProps = never;
+type DBKey = 'firestore-backup-status-v2';
+type Proto = Proto_DB_Object<DB_BackupDoc, DBKey, GeneratedProps, Versions, UniqueKeys, Dependencies>;
+export type DBProto_BackupDoc = DBProto<Proto>;
+export type UI_BackupDoc = DBProto_BackupDoc['uiType'];
+export type DB_BackupDoc = DB_Object & {
+    timestamp: number;
+    backupPath: string;
+    metadataPath: string;
+    firebasePath: string;
+    metadata: BackupMetaData;
+};
+export type ActDetailsDoc = {
+    timestamp: number;
+    moduleKey: string;
+};
+export type BackupDoc = ActDetailsDoc & {
+    backupPath: string;
+    backupId: string;
+};
+export type FetchBackupDoc = {
+    _id: string;
+    backupFilePath: string;
+    metadataFilePath: string;
+    firebaseFilePath: string;
+    firestoreSignedUrl: string;
+    firebaseSignedUrl: string;
+    metadata: BackupMetaData;
+};
+export type BackupMetaData = {
+    collectionsData: {
+        dbKey: string;
+        numOfDocs: number;
+        version: string;
+    }[];
+    timestamp: number;
+};
+export {};

package/_entity/backup-doc/types.js

@@ -0,0 +1 @@
+export {};

package/_entity/deleted-doc/api-def.d.ts

@@ -0,0 +1,7 @@
+import { ApiDefResolver } from '../../types.js';
+export type RequestType_DeletedDoc = {};
+export type ResponseType_DeletedDoc = {};
+export type ApiStruct_DeletedDoc = {
+    _v1: {};
+};
+export declare const ApiDef_DeletedDoc: ApiDefResolver<ApiStruct_DeletedDoc>;

package/_entity/deleted-doc/api-def.js

@@ -0,0 +1,3 @@
+export const ApiDef_DeletedDoc = {
+    _v1: {}
+};

package/_entity/deleted-doc/db-def.d.ts

@@ -0,0 +1,3 @@
+import { DBDef_V3 } from '@nu-art/ts-common';
+import { DBProto_DeletedDoc } from './types.js';
+export declare const DBDef_DeletedDoc: DBDef_V3<DBProto_DeletedDoc>;

package/_entity/deleted-doc/db-def.js

@@ -0,0 +1,20 @@
+import { tsValidateMustExist } from '@nu-art/ts-common';
+// const Validator_ModifiableProps: DBProto_DeletedDoc['modifiablePropsValidator'] = {
+// 	__docId: tsValidateUniqueId,
+// 	__collectionName: tsValidateString(),
+// };
+const Validator_GeneratedProps = {};
+export const DBDef_DeletedDoc = {
+    modifiablePropsValidator: tsValidateMustExist,
+    generatedPropsValidator: Validator_GeneratedProps,
+    versions: ['1.0.0'],
+    dbKey: '__deleted__docs',
+    entityName: 'DeletedDoc',
+    frontend: {
+        group: 'ts-default',
+        name: 'deleted-doc'
+    },
+    backend: {
+        name: '__deleted__docs'
+    }
+};

package/_entity/deleted-doc/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './db-def.js';
+export * from './api-def.js';

package/_entity/deleted-doc/index.js

@@ -0,0 +1,4 @@
+// Generated DB Item type: DeletedDoc
+export * from './types.js';
+export * from './db-def.js';
+export * from './api-def.js';