@nu-art/thunderstorm-shared 0.400.5

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

@@ -0,0 +1,17 @@
+import { DB_Object, DBProto, Proto_DB_Object, UniqueId, VersionsDeclaration } from '@nu-art/ts-common';
+type VersionTypes_DeletedDoc = {
+    '1.0.0': DB_DeletedDoc;
+};
+type Versions = VersionsDeclaration<['1.0.0'], VersionTypes_DeletedDoc>;
+type Dependencies = {};
+type UniqueKeys = '_id';
+type GeneratedProps = never;
+type DBKey = '__deleted__docs';
+type Proto = Proto_DB_Object<DB_DeletedDoc, DBKey, GeneratedProps, Versions, UniqueKeys, Dependencies>;
+export type DBProto_DeletedDoc = DBProto<Proto>;
+export type UI_DeletedDoc = DBProto_DeletedDoc['uiType'];
+export type DB_DeletedDoc = DB_Object & {
+    __collectionName: string;
+    __docId: UniqueId;
+};
+export {};

package/_entity/deleted-doc/types.js

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

package/_entity/editable-test/api-def.d.ts

@@ -0,0 +1,7 @@
+import { ApiDefResolver } from '../../types.js';
+export type RequestType = {};
+export type ResponseType = {};
+export type ApiStruct_EditableTest = {
+    _v1: {};
+};
+export declare const ApiDef_EditableTest: ApiDefResolver<ApiStruct_EditableTest>;

package/_entity/editable-test/api-def.js

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

package/_entity/editable-test/db-def.d.ts

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

package/_entity/editable-test/db-def.js

@@ -0,0 +1,24 @@
+import { tsValidateString } from '@nu-art/ts-common';
+const Validator_ModifiableProps = {
+    'a': tsValidateString(),
+    'b': tsValidateString(),
+    'c': tsValidateString(),
+    'd': tsValidateString(),
+};
+const Validator_GeneratedProps = {
+// 
+};
+export const DBDef_EditableTest = {
+    modifiablePropsValidator: Validator_ModifiableProps,
+    generatedPropsValidator: Validator_GeneratedProps,
+    versions: ['1.0.0'],
+    dbKey: 'editable-test',
+    entityName: 'editable-test',
+    frontend: {
+        group: 'test',
+        name: 'editable-test',
+    },
+    backend: {
+        name: 'editable-test',
+    }
+};

package/_entity/editable-test/index.d.ts

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

package/_entity/editable-test/index.js

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

package/_entity/editable-test/types.d.ts

@@ -0,0 +1,18 @@
+import { DB_Object, DBProto, Proto_DB_Object, VersionsDeclaration } from '@nu-art/ts-common';
+type VersionTypes_EditableTest = {
+    '1.0.0': DB_EditableTest;
+};
+type Versions = VersionsDeclaration<['1.0.0'], VersionTypes_EditableTest>;
+type Dependencies = {};
+type UniqueKeys = '_id';
+type GeneratedProps = never;
+type Proto = Proto_DB_Object<DB_EditableTest, 'editable-test', GeneratedProps, Versions, UniqueKeys, Dependencies>;
+export type DBProto_EditableTest = DBProto<Proto>;
+export type UI_EditableTest = DBProto_EditableTest['uiType'];
+export type DB_EditableTest = DB_Object & {
+    a: string;
+    b: string;
+    c: string;
+    d: string;
+};
+export {};

package/_entity/editable-test/types.js

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

package/_entity.d.ts

@@ -0,0 +1,4 @@
+export * from './_entity/app-config/index.js';
+export * from './_entity/backup-doc/index.js';
+export * from './_entity/deleted-doc/index.js';
+export * from './_entity/editable-test/index.js';

package/_entity.js

@@ -0,0 +1,4 @@
+export * from './_entity/app-config/index.js';
+export * from './_entity/backup-doc/index.js';
+export * from './_entity/deleted-doc/index.js';
+export * from './_entity/editable-test/index.js';

package/action-processor/apis.d.ts

@@ -0,0 +1,17 @@
+import { ApiDefResolver, BodyApi, QueryApi } from '../types.js';
+export type Request_ActionToProcess = {
+    key: string;
+    data?: any;
+};
+export type ActionMetaData = {
+    key: string;
+    description: string;
+    group: string;
+};
+export type ApiStruct_ActionProcessing = {
+    vv1: {
+        execute: BodyApi<void, Request_ActionToProcess>;
+        list: QueryApi<ActionMetaData[]>;
+    };
+};
+export declare const ApiDef_ActionProcessing: ApiDefResolver<ApiStruct_ActionProcessing>;

package/action-processor/apis.js

@@ -0,0 +1,8 @@
+import { HttpMethod } from '../types.js';
+import { Minute } from '@nu-art/ts-common';
+export const ApiDef_ActionProcessing = {
+    vv1: {
+        execute: { method: HttpMethod.POST, path: 'v1/action-processor/execute', timeout: 5 * Minute },
+        list: { method: HttpMethod.GET, path: 'v1/action-processor/list' },
+    }
+};

package/action-processor/index.d.ts

@@ -0,0 +1 @@
+export * from './apis.js';

package/action-processor/index.js

@@ -0,0 +1 @@
+export * from './apis.js';

package/archiving/apis.d.ts

@@ -0,0 +1,22 @@
+import { DB_Object, UniqueId } from '@nu-art/ts-common';
+import { ApiDefResolver, BodyApi, QueryApi } from '../types.js';
+export type RequestBody_HardDeleteUnique = {
+    _id: UniqueId;
+    collectionName: string;
+    dbInstance?: DB_Object;
+};
+export type RequestQuery_DeleteAll = {
+    collectionName: string;
+};
+export type RequestQuery_GetHistory = {
+    _id: UniqueId;
+    collectionName: string;
+};
+export type ApiStruct_Archiving = {
+    vv1: {
+        hardDeleteUnique: BodyApi<void, RequestBody_HardDeleteUnique>;
+        hardDeleteAll: QueryApi<void, RequestQuery_DeleteAll>;
+        getDocumentHistory: QueryApi<DB_Object[], RequestQuery_GetHistory>;
+    };
+};
+export declare const ApiDef_Archiving: ApiDefResolver<ApiStruct_Archiving>;

package/archiving/apis.js

@@ -0,0 +1,8 @@
+import { HttpMethod } from '../types.js';
+export const ApiDef_Archiving = {
+    vv1: {
+        hardDeleteAll: { method: HttpMethod.GET, path: 'v1/archiving/hard-delete-all' },
+        hardDeleteUnique: { method: HttpMethod.POST, path: 'v1/archiving/hard-delete-unique' },
+        getDocumentHistory: { method: HttpMethod.GET, path: 'v1/archiving/get-document-history' }
+    }
+};

package/archiving/index.d.ts

@@ -0,0 +1 @@
+export * from './apis.js';

package/archiving/index.js

@@ -0,0 +1 @@
+export * from './apis.js';

package/base64-tools.d.ts

@@ -0,0 +1,3 @@
+import { TS_Object } from '@nu-art/ts-common';
+export declare function convertBase64ToObject<T extends TS_Object>(base64: string): T;
+export declare function convertObjectToBase64<T extends TS_Object>(object: T): string;

package/base64-tools.js

@@ -0,0 +1,30 @@
+import { StaticLogger } from '@nu-art/ts-common';
+function isBrowser() {
+    return typeof window !== 'undefined' && typeof window.atob === 'function';
+}
+export function convertBase64ToObject(base64) {
+    try {
+        // Check if running in the browser
+        const decoded = isBrowser()
+            ? window.atob(base64) // Browser: Use `atob`
+            : Buffer.from(base64, 'base64').toString('utf-8'); // Node.js: Use `Buffer`
+        return JSON.parse(decoded);
+    }
+    catch (err) {
+        StaticLogger.logError(err);
+        return {}; // Return an empty object of type T on failure
+    }
+}
+export function convertObjectToBase64(object) {
+    try {
+        // Check if running in the browser
+        const string = JSON.stringify(object);
+        return isBrowser()
+            ? window.btoa(string)
+            : Buffer.from(string, 'utf-8').toString('base64');
+    }
+    catch (err) {
+        StaticLogger.logError(err);
+        return '';
+    }
+}

package/collection-actions/api-def.d.ts

@@ -0,0 +1,39 @@
+import { UniqueId } from '@nu-art/ts-common';
+import { ApiDefResolver, BodyApi } from '../types.js';
+import { DBEntityDependencies } from './types.js';
+export type CollectionActions_Upgrade = {
+    collections: {
+        request: {
+            dbKeys: string[];
+            force?: boolean;
+        };
+        response: void;
+    };
+    all: {
+        request: {
+            force?: boolean;
+        };
+        response: void;
+    };
+};
+export type CollectionActions_Check = {
+    usage: {
+        request: {
+            dbKey: string;
+            itemIds: UniqueId[];
+        };
+        response: {
+            dependencies: DBEntityDependencies | undefined;
+        };
+    };
+};
+export type ApiStruct_CollectionActions = {
+    upgrade: {
+        collections: BodyApi<CollectionActions_Upgrade['collections']['response'], CollectionActions_Upgrade['collections']['request']>;
+        all: BodyApi<CollectionActions_Upgrade['all']['response'], CollectionActions_Upgrade['all']['request']>;
+    };
+    check: {
+        usage: BodyApi<CollectionActions_Check['usage']['response'], CollectionActions_Check['usage']['request']>;
+    };
+};
+export declare const ApiDef_CollectionActions: ApiDefResolver<ApiStruct_CollectionActions>;

package/collection-actions/api-def.js

@@ -0,0 +1,10 @@
+import { HttpMethod } from '../types.js';
+export const ApiDef_CollectionActions = {
+    upgrade: {
+        collections: { method: HttpMethod.POST, path: 'v1/collection-actions/upgrade/collections' },
+        all: { method: HttpMethod.POST, path: 'v1/collection-actions/upgrade/all' },
+    },
+    check: {
+        usage: { method: HttpMethod.POST, path: 'v1/collection-actions/check/usage' },
+    }
+};

package/collection-actions/index.d.ts

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

package/collection-actions/index.js

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

package/collection-actions/types.d.ts

@@ -0,0 +1,13 @@
+import { UniqueId } from '@nu-art/ts-common';
+import { ResponseError } from '@nu-art/ts-common/core/exceptions/types';
+export type DBEntityDependencyResult = {
+    [dbKey: string]: UniqueId[];
+};
+export type DBEntityDependencies = {
+    dbKey: string;
+    dependencyMap: {
+        [entityId: UniqueId]: DBEntityDependencyResult;
+    };
+};
+export declare const DBEntityDependencyErrorType = "entity-has-dependencies";
+export type DBEntityDependencyError = ResponseError<typeof DBEntityDependencyErrorType, DBEntityDependencies>;

package/collection-actions/types.js

@@ -0,0 +1 @@
+export const DBEntityDependencyErrorType = 'entity-has-dependencies';

package/consts.d.ts

@@ -0,0 +1,12 @@
+export declare const HeaderKey_Env = "x-env";
+export declare const HeaderKey_CurrentPage = "x-current-page";
+export type Browser = 'chrome';
+export declare const DefaultHttpServerConfig: {
+    bodyParserLimit: number;
+    cors: {
+        headers: string[];
+        methods: string[];
+        responseHeaders: string[];
+    };
+    host: string;
+};

package/consts.js

@@ -0,0 +1,41 @@
+/*
+ * 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 { HeaderKey_Authorization } from './headers.js';
+export const HeaderKey_Env = 'x-env';
+export const HeaderKey_CurrentPage = 'x-current-page';
+export const DefaultHttpServerConfig = {
+    'bodyParserLimit': 200,
+    'cors': {
+        'headers': [
+            HeaderKey_Authorization,
+            'x-browser-type',
+            'x-app-version'
+        ],
+        'methods': [
+            'GET',
+            'POST'
+        ],
+        'responseHeaders': [
+            HeaderKey_Authorization
+        ]
+    },
+    'host': 'localhost'
+};

package/db-api-gen/apiV1.d.ts

@@ -0,0 +1,42 @@
+import { FirestoreQuery } from '@nu-art/firebase-shared';
+import { DB_BaseObject, DB_Object, DBDef, IndexKeys, Metadata, PreDB } from '@nu-art/ts-common';
+import { ApiDefResolver, BodyApi, QueryApi, QueryParams } from '../types.js';
+import { ResponseError } from '@nu-art/ts-common/core/exceptions/types';
+/**
+ * !! Workaround !!
+ *
+ * there is a typescript bug... should be able to use
+ *
+ * upsert: BodyApi<DBType, PreDB<DBType>>,
+ * patch: BodyApi<DBType, PreDB<DBType>>
+ *
+ * but something about the type resolution goes wrong and instead of seeing Type<GenericType>, it resolves to Type> which makes no sense
+ */
+export type ApiStruct_DBApiGen<DBType extends DB_Object> = {
+    v1: {
+        query: BodyApi<DBType[], FirestoreQuery<DBType>, FirestoreQuery<DBType> | undefined | {}>;
+        queryUnique: QueryApi<DBType, DB_BaseObject, ResponseError<string, any>, string>;
+        upsert: BodyApi<DBType, PreDB<DBType>>;
+        upsertAll: BodyApi<DBType[], PreDB<DBType>[]>;
+        patch: BodyApi<DBType, PreDB<DBType>>;
+        delete: QueryApi<DBType, DB_BaseObject>;
+        deleteQuery: BodyApi<DBType[], FirestoreQuery<DBType>>;
+        deleteAll: QueryApi<void>;
+        metadata: QueryApi<Metadata<DBType>>;
+    };
+};
+export type ApiStruct_DBApiGenIDB<DBType extends DB_Object, Ks extends keyof DBType> = {
+    v1: {
+        query: BodyApi<DBType[], FirestoreQuery<DBType>>;
+        queryUnique: QueryApi<DBType, QueryParams, ResponseError<string, any>, string | IndexKeys<DBType, Ks>>;
+        upsert: BodyApi<DBType, PreDB<DBType>>;
+        upsertAll: BodyApi<DBType[], PreDB<DBType>[]>;
+        patch: BodyApi<DBType, IndexKeys<DBType, Ks> & Partial<DBType>>;
+        delete: QueryApi<DBType, DB_BaseObject>;
+        deleteQuery: BodyApi<DBType[], FirestoreQuery<DBType>>;
+        deleteAll: QueryApi<DBType[]>;
+        metadata: QueryApi<Metadata<DBType>>;
+    };
+};
+export declare const DBApiDefGenerator: <DBType extends DB_Object>(dbDef: DBDef<DBType, "_id">) => ApiDefResolver<ApiStruct_DBApiGen<DBType>>;
+export declare const DBApiDefGeneratorIDB: <DBType extends DB_Object, Ks extends keyof DBType>(dbDef: DBDef<DBType, Ks>) => ApiDefResolver<ApiStruct_DBApiGenIDB<DBType, Ks>>;

package/db-api-gen/apiV1.js

@@ -0,0 +1,51 @@
+/*
+ * Database API Generator is a utility library for Thunderstorm.
+ *
+ * Given proper configurations it will dynamically generate APIs to your Firestore
+ * collections, will assert uniqueness and restrict deletion... and more
+ *
+ * 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 { HttpMethod } from '../types.js';
+export const DBApiDefGenerator = (dbDef) => {
+    return {
+        v1: {
+            query: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/query` },
+            queryUnique: { method: HttpMethod.GET, path: `v1/${dbDef.dbKey}/query-unique` },
+            upsert: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/upsert` },
+            upsertAll: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/upsert-all` },
+            patch: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/patch` },
+            delete: { method: HttpMethod.GET, path: `v1/${dbDef.dbKey}/delete-unique` },
+            deleteQuery: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/delete` },
+            deleteAll: { method: HttpMethod.GET, path: `v1/${dbDef.dbKey}/delete-all` },
+            metadata: { method: HttpMethod.GET, path: `v1/${dbDef.dbKey}/metadata` },
+        }
+    };
+};
+export const DBApiDefGeneratorIDB = (dbDef) => {
+    return {
+        v1: {
+            query: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/query` },
+            queryUnique: { method: HttpMethod.GET, path: `v1/${dbDef.dbKey}/query-unique` },
+            upsert: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/upsert` },
+            upsertAll: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/upsert-all` },
+            patch: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/patch` },
+            delete: { method: HttpMethod.GET, path: `v1/${dbDef.dbKey}/delete-unique` },
+            deleteQuery: { method: HttpMethod.POST, path: `v1/${dbDef.dbKey}/delete` },
+            deleteAll: { method: HttpMethod.GET, path: `v1/${dbDef.dbKey}/delete-all` },
+            metadata: { method: HttpMethod.GET, path: `v1/${dbDef.dbKey}/metadata` },
+        }
+    };
+};

package/db-api-gen/apiV2.d.ts

@@ -0,0 +1,42 @@
+import { FirestoreQuery } from '@nu-art/firebase-shared';
+import { DB_BaseObject, DB_Object, DBDef, IndexKeys, Metadata, PreDB } from '@nu-art/ts-common';
+import { ApiDefResolver, BodyApi, QueryApi } from '../types.js';
+import { ResponseError } from '@nu-art/ts-common/core/exceptions/types';
+/**
+ * !! Workaround !!
+ *
+ * there is a typescript bug... should be able to use
+ *
+ * upsert: BodyApi<DBType, PreDB<DBType>>,
+ * patch: BodyApi<DBType, PreDB<DBType>>
+ *
+ * but something about the type resolution goes wrong and instead of seeing Type<GenericType>, it resolves to Type> which makes no sense
+ */
+export type ApiStruct_DBApiGenV2<DBType extends DB_Object> = {
+    v1: {
+        query: BodyApi<DBType[], FirestoreQuery<DBType>, FirestoreQuery<DBType> | undefined | {}>;
+        queryUnique: QueryApi<DBType, DB_BaseObject, ResponseError<string, any>, string>;
+        upsert: BodyApi<DBType, PreDB<DBType>>;
+        upsertAll: BodyApi<DBType[], PreDB<DBType>[]>;
+        patch: BodyApi<DBType, PreDB<DBType>>;
+        delete: QueryApi<DBType, DB_BaseObject>;
+        deleteQuery: BodyApi<DBType[], FirestoreQuery<DBType>>;
+        deleteAll: QueryApi<void>;
+        metadata: QueryApi<Metadata<DBType>>;
+    };
+};
+export type ApiStruct_DBApiGenIDBV2<DBType extends DB_Object, Ks extends keyof DBType> = {
+    v1: {
+        query: BodyApi<DBType[], FirestoreQuery<DBType>>;
+        queryUnique: QueryApi<DBType, DB_BaseObject, ResponseError<string, any>, string | IndexKeys<DBType, Ks>>;
+        upsert: BodyApi<DBType, PreDB<DBType>>;
+        upsertAll: BodyApi<DBType[], PreDB<DBType>[]>;
+        patch: BodyApi<DBType, IndexKeys<DBType, Ks> & Partial<DBType>>;
+        delete: QueryApi<DBType | undefined, DB_BaseObject>;
+        deleteQuery: BodyApi<DBType[], FirestoreQuery<DBType>>;
+        deleteAll: QueryApi<DBType[]>;
+        metadata: QueryApi<Metadata<DBType>>;
+    };
+};
+export declare const DBApiDefGeneratorV2: <DBType extends DB_Object>(dbDef: DBDef<DBType, "_id">, version?: string) => ApiDefResolver<ApiStruct_DBApiGenV2<DBType>>;
+export declare const DBApiDefGeneratorIDBV2: <DBType extends DB_Object, Ks extends keyof DBType>(dbDef: DBDef<DBType, Ks>, version?: string) => ApiDefResolver<ApiStruct_DBApiGenIDBV2<DBType, Ks>>;

package/db-api-gen/apiV2.js

@@ -0,0 +1,51 @@
+/*
+ * Database API Generator is a utility library for Thunderstorm.
+ *
+ * Given proper configurations it will dynamically generate APIs to your Firestore
+ * collections, will assert uniqueness and restrict deletion... and more
+ *
+ * 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 { HttpMethod } from '../types.js';
+export const DBApiDefGeneratorV2 = (dbDef, version = 'v1') => {
+    return {
+        v1: {
+            query: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/query` },
+            queryUnique: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/query-unique` },
+            upsert: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/upsert` },
+            upsertAll: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/upsert-all` },
+            patch: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/patch` },
+            delete: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/delete-unique` },
+            deleteQuery: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/delete` },
+            deleteAll: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/delete-all` },
+            metadata: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/metadata` },
+        }
+    };
+};
+export const DBApiDefGeneratorIDBV2 = (dbDef, version = 'v1') => {
+    return {
+        v1: {
+            query: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/query` },
+            queryUnique: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/query-unique` },
+            upsert: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/upsert` },
+            upsertAll: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/upsert-all` },
+            patch: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/patch` },
+            delete: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/delete-unique` },
+            deleteQuery: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/delete` },
+            deleteAll: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/delete-all` },
+            metadata: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/metadata` },
+        }
+    };
+};

package/db-api-gen/apiV3.d.ts

@@ -0,0 +1,42 @@
+import { EntityDependencyError, FirestoreQuery } from '@nu-art/firebase-shared';
+import { DB_BaseObject, DBDef_V3, DBProto, IndexKeys, Metadata } from '@nu-art/ts-common';
+import { ApiDefResolver, BodyApi, QueryApi } from '../types.js';
+import { ResponseError } from '@nu-art/ts-common/core/exceptions/types';
+/**
+ * !! Workaround !!
+ *
+ * there is a typescript bug... should be able to use
+ *
+ * upsert: BodyApi<DBType, PreDB<DBType>>,
+ * patch: BodyApi<DBType, PreDB<DBType>>
+ *
+ * but something about the type resolution goes wrong and instead of seeing Type<GenericType>, it resolves to Type> which makes no sense
+ */
+export type ApiStruct_DBApiGenV3<Proto extends DBProto<any>> = {
+    v1: {
+        query: BodyApi<Proto['dbType'][], FirestoreQuery<Proto['dbType']>, FirestoreQuery<Proto['dbType']> | undefined | {}>;
+        queryUnique: QueryApi<Proto['dbType'], DB_BaseObject, ResponseError<string, any>, string>;
+        upsert: BodyApi<Proto['dbType'], Proto['uiType']>;
+        upsertAll: BodyApi<Proto['dbType'][], Proto['uiType'][]>;
+        patch: BodyApi<Proto['dbType'], Proto['uiType']>;
+        delete: QueryApi<Proto['dbType'], DB_BaseObject>;
+        deleteQuery: BodyApi<Proto['dbType'][], FirestoreQuery<Proto['dbType']>>;
+        deleteAll: QueryApi<void>;
+        metadata: QueryApi<Metadata<Proto['dbType']>>;
+    };
+};
+export type ApiStruct_DBApiGenIDBV3<Proto extends DBProto<any>> = {
+    v1: {
+        query: BodyApi<Proto['dbType'][], FirestoreQuery<Proto['dbType']>>;
+        queryUnique: QueryApi<Proto['dbType'], DB_BaseObject, ResponseError<string, any>, string | IndexKeys<Proto['dbType'], keyof Proto['dbType']>>;
+        upsert: BodyApi<Proto['dbType'], Proto['uiType']>;
+        upsertAll: BodyApi<Proto['dbType'][], Proto['uiType'][]>;
+        patch: BodyApi<Proto['dbType'], IndexKeys<Proto['dbType'], keyof Proto['dbType']> & Partial<Proto['dbType']>>;
+        delete: QueryApi<Proto['dbType'] | undefined, DB_BaseObject, EntityDependencyError>;
+        deleteQuery: BodyApi<Proto['dbType'][], FirestoreQuery<Proto['dbType']>>;
+        deleteAll: QueryApi<Proto['dbType'][]>;
+        metadata: QueryApi<Metadata<Proto['dbType']>>;
+    };
+};
+export declare const DBApiDefGeneratorV3: <Proto extends DBProto<any>>(dbDef: DBDef_V3<Proto>, version?: string) => ApiDefResolver<ApiStruct_DBApiGenV3<Proto>>;
+export declare const DBApiDefGeneratorIDBV3: <Proto extends DBProto<any>>(dbDef: DBDef_V3<Proto>, version?: string) => ApiDefResolver<ApiStruct_DBApiGenIDBV3<Proto>>;

package/db-api-gen/apiV3.js

@@ -0,0 +1,51 @@
+/*
+ * Database API Generator is a utility library for Thunderstorm.
+ *
+ * Given proper configurations it will dynamically generate APIs to your Firestore
+ * collections, will assert uniqueness and restrict deletion... and more
+ *
+ * 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 { HttpMethod } from '../types.js';
+export const DBApiDefGeneratorV3 = (dbDef, version = 'v1') => {
+    return {
+        v1: {
+            query: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/query`, timeout: 60000 },
+            queryUnique: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/query-unique` },
+            upsert: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/upsert` },
+            upsertAll: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/upsert-all` },
+            patch: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/patch` },
+            delete: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/delete-unique` },
+            deleteQuery: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/delete` },
+            deleteAll: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/delete-all` },
+            metadata: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/metadata` },
+        }
+    };
+};
+export const DBApiDefGeneratorIDBV3 = (dbDef, version = 'v1') => {
+    return {
+        v1: {
+            query: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/query`, timeout: 60000 },
+            queryUnique: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/query-unique` },
+            upsert: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/upsert` },
+            upsertAll: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/upsert-all` },
+            patch: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/patch` },
+            delete: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/delete-unique` },
+            deleteQuery: { method: HttpMethod.POST, path: `${version}/${dbDef.dbKey}/delete` },
+            deleteAll: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/delete-all` },
+            metadata: { method: HttpMethod.GET, path: `${version}/${dbDef.dbKey}/metadata` },
+        }
+    };
+};