@mxpicture/gcp-functions-backend 0.1.44 → 0.1.45

package/dist/api/BackendApi.d.ts

@@ -5,7 +5,7 @@ import type { Validation } from "../validation/Validation.js";
 import type { ZodRawShape } from "zod";
 import { IBackendApi } from "./IBackendApi.js";
 export declare class BackendApi<DTO extends DocumentData, STORE extends Store<DTO> = Store<DTO>, VAL extends Validation<DTO> = Validation<DTO>> extends IBackendApi<DTO, STORE, VAL> implements ApiFromRoutes<CrudRoutes<DTO>> {
-    constructor(storeC: CallbackAble<STORE>, validationC: CallbackAble<VAL>, shapeC: CallbackAble<ZodRawShape>);
+    constructor(name: string, storeC: CallbackAble<STORE>, validationC: CallbackAble<VAL>, shapeC: CallbackAble<ZodRawShape>);
     delete(request: DocumentKey): Promise<{
         deleted: true;
     }>;

package/dist/api/BackendApi.js

@@ -1,8 +1,8 @@
 import { Meta } from "@mxpicture/zod-meta";
 import { IBackendApi } from "./IBackendApi.js";
 export class BackendApi extends IBackendApi {
-    constructor(storeC, validationC, shapeC) {
-        super(storeC, validationC, shapeC);
+    constructor(name, storeC, validationC, shapeC) {
+        super(name, storeC, validationC, shapeC);
     }
     async delete(request) {
         await (await this.store()).delete(request.id);

package/dist/api/IBackendApi.d.ts

@@ -3,13 +3,14 @@ import { Store } from "../store/Store.js";
 import type { Validation } from "../validation/Validation.js";
 import type { ZodRawShape } from "zod";
 export declare class IBackendApi<DTO extends DocumentData, STORE extends Store<DTO> = Store<DTO>, VAL extends Validation<DTO> = Validation<DTO>> {
+    readonly name: string;
     protected readonly storeC: CallbackAble<STORE>;
     protected readonly validationC: CallbackAble<VAL>;
     protected readonly shapeC: CallbackAble<ZodRawShape>;
     protected _store?: STORE;
     protected _validation?: VAL;
     protected _shape?: ZodRawShape;
-    protected constructor(storeC: CallbackAble<STORE>, validationC: CallbackAble<VAL>, shapeC: CallbackAble<ZodRawShape>);
+    protected constructor(name: string, storeC: CallbackAble<STORE>, validationC: CallbackAble<VAL>, shapeC: CallbackAble<ZodRawShape>);
     protected store(): Promise<STORE>;
     protected validation(): Promise<VAL>;
     protected shape(): Promise<ZodRawShape>;

package/dist/api/IBackendApi.js

@@ -1,12 +1,14 @@
 import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
 export class IBackendApi {
+    name;
     storeC;
     validationC;
     shapeC;
     _store;
     _validation;
     _shape;
-    constructor(storeC, validationC, shapeC) {
+    constructor(name, storeC, validationC, shapeC) {
+        this.name = name;
         this.storeC = storeC;
         this.validationC = validationC;
         this.shapeC = shapeC;

package/dist/function/BackendFunction.d.ts

@@ -1,22 +1 @@
-import type { DocumentData, CallbackAble, CrudRoutes, ApiFilter, DocumentKey, WithKey, WithoutKey } from "@mxpicture/gcp-functions-common/types";
-import { BackendApi } from "../api/BackendApi.js";
-import { FunctionFromRoutes, FunctionResponse } from "../../../common/src/types/types.function.js";
-import { MetaItem } from "@mxpicture/zod-meta";
-import { IBackendFunction } from "./IBackendFunction.js";
-export declare class BackendFunction<DTO extends DocumentData, API extends BackendApi<DTO>> extends IBackendFunction<DTO, API> implements FunctionFromRoutes<CrudRoutes<DTO>> {
-    constructor(name: string, apiC: CallbackAble<API>, additionalRoutes?: string[]);
-    create(request: WithoutKey<DTO>): Promise<FunctionResponse<WithKey<DTO>>>;
-    update(request: WithKey<Partial<DTO>>): Promise<FunctionResponse<WithKey<DTO>>>;
-    delete(request: DocumentKey): Promise<FunctionResponse<{
-        deleted: true;
-    }>>;
-    get(request: DocumentKey): Promise<FunctionResponse<WithKey<DTO>>>;
-    query(request: ApiFilter | null | undefined): Promise<FunctionResponse<WithKey<DTO>[]>>;
-    count(request: ApiFilter | null | undefined): Promise<FunctionResponse<{
-        count: number;
-    }>>;
-    exists(request: DocumentKey): Promise<FunctionResponse<{
-        exists: boolean;
-    }>>;
-    meta(): Promise<FunctionResponse<MetaItem[]>>;
-}
+export {};

package/dist/function/BackendFunction.js

@@ -1,31 +1,72 @@
-import { IBackendFunction } from "./IBackendFunction.js";
-import { CRUD_ROUTES } from "@mxpicture/gcp-functions-common/config";
-export class BackendFunction extends IBackendFunction {
-    constructor(name, apiC, additionalRoutes) {
-        super(name, apiC, [...CRUD_ROUTES, ...(additionalRoutes ?? [])]);
-    }
-    async create(request) {
-        return this.ingress({ data: request, route: "create" });
-    }
-    async update(request) {
-        return this.ingress({ data: request, route: "update" });
-    }
-    async delete(request) {
-        return this.ingress({ data: request, route: "delete" });
-    }
-    async get(request) {
-        return this.ingress({ data: request, route: "get" });
-    }
-    async query(request) {
-        return this.ingress({ data: request, route: "query" });
-    }
-    async count(request) {
-        return this.ingress({ data: request, route: "count" });
-    }
-    async exists(request) {
-        return this.ingress({ data: request, route: "exists" });
-    }
-    async meta() {
-        return this.ingress({ route: "meta", data: null });
-    }
-}
+// todo not needed anymore?
+// import type {
+//   DocumentData,
+//   CallbackAble,
+//   CrudRoutes,
+//   ApiFilter,
+//   DocumentKey,
+//   WithKey,
+//   WithoutKey,
+// } from "@mxpicture/gcp-functions-common/types";
+// import { BackendApi } from "../api/BackendApi.js";
+// import {
+//   FunctionFromRoutes,
+//   FunctionResponse,
+// } from "../../../common/src/types/types.function.js";
+// import { MetaItem } from "@mxpicture/zod-meta";
+// import { IBackendFunction } from "./IBackendFunction.js";
+// import { CRUD_ROUTES } from "@mxpicture/gcp-functions-common/config";
+export {};
+// export class BackendFunction<
+//     DTO extends DocumentData,
+//     API extends BackendApi<DTO>,
+//   >
+//   extends IBackendFunction<DTO, API>
+//   implements FunctionFromRoutes<CrudRoutes<DTO>>
+// {
+//   public constructor(
+//     name: string,
+//     apiC: CallbackAble<API>,
+//     additionalRoutes?: string[],
+//   ) {
+//     super(name, apiC, [...CRUD_ROUTES, ...(additionalRoutes ?? [])]);
+//   }
+//   public async create(
+//     request: WithoutKey<DTO>,
+//   ): Promise<FunctionResponse<WithKey<DTO>>> {
+//     return this.ingress({ data: request, route: "create" });
+//   }
+//   public async update(
+//     request: WithKey<Partial<DTO>>,
+//   ): Promise<FunctionResponse<WithKey<DTO>>> {
+//     return this.ingress({ data: request, route: "update" });
+//   }
+//   public async delete(
+//     request: DocumentKey,
+//   ): Promise<FunctionResponse<{ deleted: true }>> {
+//     return this.ingress({ data: request, route: "delete" });
+//   }
+//   public async get(
+//     request: DocumentKey,
+//   ): Promise<FunctionResponse<WithKey<DTO>>> {
+//     return this.ingress({ data: request, route: "get" });
+//   }
+//   public async query(
+//     request: ApiFilter | null | undefined,
+//   ): Promise<FunctionResponse<WithKey<DTO>[]>> {
+//     return this.ingress({ data: request, route: "query" });
+//   }
+//   public async count(
+//     request: ApiFilter | null | undefined,
+//   ): Promise<FunctionResponse<{ count: number }>> {
+//     return this.ingress({ data: request, route: "count" });
+//   }
+//   public async exists(
+//     request: DocumentKey,
+//   ): Promise<FunctionResponse<{ exists: boolean }>> {
+//     return this.ingress({ data: request, route: "exists" });
+//   }
+//   public async meta(): Promise<FunctionResponse<MetaItem[]>> {
+//     return this.ingress({ route: "meta", data: null });
+//   }
+// }

package/dist/function/IBackendFunction.d.ts

@@ -3,12 +3,14 @@ import { BackendApi } from "../api/BackendApi.js";
 import { CallableFunction } from "firebase-functions/v2/https";
 import { FunctionRequest, FunctionResponse } from "../../../common/src/types/types.function.js";
 export declare class IBackendFunction<DTO extends DocumentData, API extends BackendApi<DTO>> {
-    readonly name: string;
     protected apiC: CallbackAble<API>;
-    protected readonly routes: string[];
+    protected readonly routesC: CallbackAble<string[]>;
     protected _api?: API;
-    protected constructor(name: string, apiC: CallbackAble<API>, routes: string[]);
+    protected _routes?: string[];
+    protected constructor(apiC: CallbackAble<API>, routesC: CallbackAble<string[]>);
+    name(): Promise<string>;
     protected api(): Promise<API>;
+    protected routes(): Promise<string[]>;
     ingress<REQ, RES extends DocumentData>(request: FunctionRequest<REQ>): Promise<FunctionResponse<RES>>;
     buildFunction(): CallableFunction<FunctionRequest<any>, Promise<FunctionResponse<any>>>;
 }

package/dist/function/IBackendFunction.js

@@ -1,22 +1,30 @@
 import { onCall, HttpsError, } from "firebase-functions/v2/https";
 import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
 export class IBackendFunction {
-    name;
     apiC;
-    routes;
+    routesC;
     _api;
-    constructor(name, apiC, routes) {
-        this.name = name;
+    _routes;
+    constructor(apiC, routesC) {
         this.apiC = apiC;
-        this.routes = routes;
+        this.routesC = routesC;
+    }
+    async name() {
+        return (await this.api()).name;
     }
     async api() {
         if (!this._api)
             this._api = await callableUnwrap(this.apiC);
         return this._api;
     }
+    async routes() {
+        if (!this._routes)
+            this._routes = await callableUnwrap(this.routesC);
+        return this._routes;
+    }
     async ingress(request) {
-        if (!this.routes.find((m) => m === request.route))
+        const routes = await this.routes();
+        if (!routes.find((m) => m === request.route))
             throw new HttpsError("invalid-argument", `Route ${request.route} not available`);
         try {
             return {

package/dist/function/index.d.ts

@@ -1,2 +1 @@
-export { BackendFunction } from "./BackendFunction.js";
 export { IBackendFunction } from "./IBackendFunction.js";

package/dist/function/index.js

@@ -1,2 +1 @@
-export { BackendFunction } from "./BackendFunction.js";
 export { IBackendFunction } from "./IBackendFunction.js";

package/package.json

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