@mxpicture/gcp-functions-backend 0.1.28 → 0.1.30

package/dist/api/BackendApi.d.ts

@@ -1,14 +1,20 @@
 import type { MetaItem } from "@mxpicture/zod-meta";
-import type { ApiKey, ApiFilter, DocumentData, WithKey } from "@mxpicture/gcp-functions-common/types";
+import type { ApiKey, ApiFilter, DocumentData, WithKey, CallbackAble } from "@mxpicture/gcp-functions-common/types";
 import { IApi } from "@mxpicture/gcp-functions-common/api";
 import { Store } from "../store/Store.js";
 import type { Validation } from "../validation/Validation.js";
 import type { ZodRawShape } from "zod";
 export declare class BackendApi<DTO extends DocumentData, STORE extends Store<DTO> = Store<DTO>, VAL extends Validation<DTO> = Validation<DTO>> extends IApi<DTO> {
-    readonly store: STORE;
-    readonly validation: VAL;
-    protected shape: ZodRawShape;
-    constructor(store: STORE, validation: VAL, shape: ZodRawShape);
+    protected readonly storeC: CallbackAble<STORE>;
+    protected readonly validationC: CallbackAble<VAL>;
+    protected readonly shapeC: CallbackAble<ZodRawShape>;
+    protected _store?: STORE;
+    protected _validation?: VAL;
+    protected _shape?: ZodRawShape;
+    constructor(storeC: CallbackAble<STORE>, validationC: CallbackAble<VAL>, shapeC: CallbackAble<ZodRawShape>);
+    protected store(): Promise<STORE>;
+    protected validation(): Promise<VAL>;
+    protected shape(): Promise<ZodRawShape>;
     delete(p: ApiKey): Promise<void>;
     get(p: ApiKey): Promise<WithKey<DTO>>;
     query(payload?: ApiFilter): Promise<WithKey<DTO>[]>;

package/dist/api/BackendApi.js

@@ -1,39 +1,58 @@
 import { Meta } from "@mxpicture/zod-meta";
 import { IApi } from "@mxpicture/gcp-functions-common/api";
+import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
 export class BackendApi extends IApi {
-    store;
-    validation;
-    shape;
-    constructor(store, validation, shape) {
+    storeC;
+    validationC;
+    shapeC;
+    _store;
+    _validation;
+    _shape;
+    constructor(storeC, validationC, shapeC) {
         super();
-        this.store = store;
-        this.validation = validation;
-        this.shape = shape;
+        this.storeC = storeC;
+        this.validationC = validationC;
+        this.shapeC = shapeC;
+    }
+    async store() {
+        if (!this._store)
+            this._store = await callableUnwrap(this.storeC);
+        return this._store;
+    }
+    async validation() {
+        if (!this._validation)
+            this._validation = await callableUnwrap(this.validationC);
+        return this._validation;
+    }
+    async shape() {
+        if (!this._shape)
+            this._shape = await callableUnwrap(this.shapeC);
+        return this._shape;
     }
     async delete(p) {
-        return this.store.delete(p.id);
+        return (await this.store()).delete(p.id);
     }
     async get(p) {
-        return this.store.get(p.id);
+        return (await this.store()).get(p.id);
     }
     async query(payload) {
-        return this.store.query(payload?.filters);
+        return (await this.store()).query(payload?.filters);
     }
     async count(payload) {
-        return { count: await this.store.count(payload?.filters) };
+        return { count: await (await this.store()).count(payload?.filters) };
     }
     async exists(p) {
-        return { exists: await this.store.exists(p.id) };
+        return { exists: await (await this.store()).exists(p.id) };
     }
     async meta() {
-        return new Meta(this.shape).items();
+        return new Meta(await this.shape()).items();
     }
     async create(data) {
-        const result = await this.validation.validate(data);
-        return this.store.create(result);
+        const result = await (await this.validation()).validate(data);
+        return (await this.store()).create(result);
     }
     async update(p, data) {
-        const result = await this.validation.validatePartial(data);
-        return this.store.update(p.id, result);
+        const result = await (await this.validation()).validatePartial(data);
+        return (await this.store()).update(p.id, result);
     }
 }

package/dist/function/BackendFunction.d.ts

@@ -1,9 +1,11 @@
 import { HttpsFunction } from "firebase-functions/https";
-import type { HttpHandlers, DocumentData, ApiRoutes } from "@mxpicture/gcp-functions-common/types";
+import type { HttpHandlers, DocumentData, ApiRoutes, CallbackAble } from "@mxpicture/gcp-functions-common/types";
 export declare class BackendFunction<DTO extends DocumentData, HANDLER extends HttpHandlers<ApiRoutes<DTO>> = HttpHandlers<ApiRoutes<DTO>>> {
     readonly name: string;
-    protected http: HANDLER;
+    protected httpC: CallbackAble<HANDLER>;
     protected readonly httpMethods: string[];
-    constructor(name: string, http: HANDLER);
+    protected _http?: HANDLER;
+    constructor(name: string, httpC: CallbackAble<HANDLER>);
+    protected http(): Promise<HANDLER>;
     createFunction(): HttpsFunction;
 }

package/dist/function/BackendFunction.js

@@ -1,14 +1,21 @@
 import { HttpsError, onCall } from "firebase-functions/https";
 import { API_ROUTES_METHODS } from "@mxpicture/gcp-functions-common/config";
+import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
 export class BackendFunction {
     name;
-    http;
+    httpC;
     httpMethods;
-    constructor(name, http) {
+    _http;
+    constructor(name, httpC) {
         this.name = name;
-        this.http = http;
+        this.httpC = httpC;
         this.httpMethods = API_ROUTES_METHODS;
     }
+    async http() {
+        if (!this._http)
+            this._http = await callableUnwrap(this.httpC);
+        return this._http;
+    }
     createFunction() {
         return onCall({
             cors: [
@@ -26,7 +33,7 @@ export class BackendFunction {
                 throw new HttpsError("invalid-argument", `Route ${req.data.route} not available`);
             return {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                doc: await this.http[req.data.route](req.data),
+                doc: await (await this.http())[req.data.route](req.data),
             };
         });
     }

package/dist/http/BackendHttp.d.ts

@@ -1,8 +1,10 @@
-import type { HttpHandlers, FunctionPayload, ApiFilter, ApiKey, ApiRoutes, DocumentData } from "@mxpicture/gcp-functions-common/types";
+import type { HttpHandlers, FunctionPayload, ApiFilter, ApiKey, ApiRoutes, DocumentData, CallbackAble } from "@mxpicture/gcp-functions-common/types";
 import { BackendApi } from "../api/BackendApi.js";
 export declare class BackendHttp<DTO extends DocumentData, API extends BackendApi<DTO> = BackendApi<DTO>> implements HttpHandlers<ApiRoutes<DTO>> {
-    protected api: API;
-    constructor(api: API);
+    protected apiC: CallbackAble<API>;
+    protected _api?: API;
+    constructor(apiC: CallbackAble<API>);
+    protected api(): Promise<API>;
     delete(req: FunctionPayload<never, ApiKey>): Promise<void>;
     get(req: FunctionPayload<never, ApiKey>): Promise<import("@mxpicture/gcp-functions-common/types").WithKey<DTO>>;
     query(req: FunctionPayload<ApiFilter>): Promise<import("@mxpicture/gcp-functions-common/types").WithKey<DTO>[]>;

package/dist/http/BackendHttp.js

@@ -1,15 +1,22 @@
 import { HttpsError } from "firebase-functions/https";
+import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
 export class BackendHttp {
-    api;
-    constructor(api) {
-        this.api = api;
+    apiC;
+    _api;
+    constructor(apiC) {
+        this.apiC = apiC;
+    }
+    async api() {
+        if (!this._api)
+            this._api = await callableUnwrap(this.apiC);
+        return this._api;
     }
     async delete(req) {
         try {
             const id = req.keys?.id;
             if (!id)
                 throw new HttpsError("invalid-argument", "Id invalid");
-            await this.api.delete({ id });
+            await (await this.api()).delete({ id });
         }
         catch (error) {
             if (error instanceof HttpsError)
@@ -22,7 +29,7 @@ export class BackendHttp {
             const id = req.keys?.id;
             if (!id)
                 throw new HttpsError("invalid-argument", "Id invalid");
-            return this.api.get({ id });
+            return (await this.api()).get({ id });
         }
         catch (error) {
             if (error instanceof HttpsError)
@@ -32,7 +39,7 @@ export class BackendHttp {
     }
     async query(req) {
         try {
-            return this.api.query(req.content);
+            return (await this.api()).query(req.content);
         }
         catch (error) {
             if (error instanceof HttpsError)
@@ -42,7 +49,7 @@ export class BackendHttp {
     }
     async count(req) {
         try {
-            return this.api.count(req.content);
+            return (await this.api()).count(req.content);
         }
         catch (error) {
             if (error instanceof HttpsError)
@@ -55,7 +62,7 @@ export class BackendHttp {
             const id = req.keys?.id;
             if (!id)
                 throw new HttpsError("invalid-argument", "Id invalid");
-            return await this.api.exists({ id });
+            return await (await this.api()).exists({ id });
         }
         catch (error) {
             if (error instanceof HttpsError)
@@ -65,7 +72,7 @@ export class BackendHttp {
     }
     async meta() {
         try {
-            return this.api.meta();
+            return (await this.api()).meta();
         }
         catch (error) {
             if (error instanceof HttpsError)
@@ -77,7 +84,7 @@ export class BackendHttp {
         try {
             if (!req.content)
                 throw new HttpsError("invalid-argument", "Content is invalid");
-            return this.api.create(req.content);
+            return (await this.api()).create(req.content);
         }
         catch (error) {
             if (error instanceof HttpsError)
@@ -92,7 +99,7 @@ export class BackendHttp {
                 throw new HttpsError("invalid-argument", "Id invalid");
             if (!req.content)
                 throw new HttpsError("invalid-argument", "Content is invalid");
-            return this.api.update({ id }, req.content);
+            return (await this.api()).update({ id }, req.content);
         }
         catch (error) {
             if (error instanceof HttpsError)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxpicture/gcp-functions-backend",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "Utils for google cloud functions, publishing both CommonJS and ESM builds",
   "type": "module",
   "author": "MXPicture",