@mxpicture/gcp-functions-backend 0.1.48 → 0.1.50

package/dist/api/BackendApi.d.ts

@@ -1,11 +1,9 @@
-import type { MetaItem } from "@mxpicture/zod-meta";
-import type { DocumentData, WithKey, CallbackAble, ApiFromRoutes, CrudRoutes, WithoutKey, DocumentKey, ApiFilter } from "@mxpicture/gcp-functions-common/types";
+import type { DocumentData, WithKey, ApiFromRoutes, CrudRoutes, WithoutKey, DocumentKey, ApiFilter } from "@mxpicture/gcp-functions-common/types";
 import { Store } from "../store/Store.js";
 import type { Validation } from "../validation/Validation.js";
-import type { ZodRawShape } from "zod";
 import { IBackendApi } from "./IBackendApi.js";
+import type { MetaItem } from "@mxpicture/gcp-functions-common/meta";
 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(name: string, storeC: CallbackAble<STORE>, validationC: CallbackAble<VAL>, shapeC: CallbackAble<ZodRawShape>);
     delete(request: DocumentKey): Promise<{
         deleted: true;
     }>;

package/dist/api/BackendApi.js

@@ -1,34 +1,30 @@
-import { Meta } from "@mxpicture/zod-meta";
 import { IBackendApi } from "./IBackendApi.js";
 export class BackendApi extends IBackendApi {
-    constructor(name, storeC, validationC, shapeC) {
-        super(name, storeC, validationC, shapeC);
-    }
     async delete(request) {
-        await (await this.store()).delete(request.id);
+        await this.store().delete(request.id);
         return { deleted: true };
     }
     async get(request) {
-        return (await this.store()).get(request.id);
+        return this.store().get(request.id);
     }
     async query(request) {
-        return (await this.store()).query(request?.filters);
+        return this.store().query(request?.filters);
     }
     async count(request) {
-        return { count: await (await this.store()).count(request?.filters) };
+        return { count: await this.store().count(request?.filters) };
     }
     async exists(request) {
-        return { exists: await (await this.store()).exists(request.id) };
+        return { exists: await this.store().exists(request.id) };
     }
     async meta() {
-        return new Meta(await this.shape()).items();
+        throw new Error("not implemented"); // todo
     }
     async create(request) {
-        const result = await (await this.validation()).validate(request);
-        return (await this.store()).create(result);
+        const result = this.validation().validate(request);
+        return this.store().create(result);
     }
     async update(request) {
-        const result = await (await this.validation()).validatePartial(request);
-        return (await this.store()).update(request.id, result);
+        const result = this.validation().validatePartial(request);
+        return this.store().update(request.id, result);
     }
 }

package/dist/api/IBackendApi.d.ts

@@ -1,17 +1,13 @@
-import type { DocumentData, CallbackAble } from "@mxpicture/gcp-functions-common/types";
+import type { DocumentData } from "@mxpicture/gcp-functions-common/types";
 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>> {
+export declare abstract 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(name: string, storeC: CallbackAble<STORE>, validationC: CallbackAble<VAL>, shapeC: CallbackAble<ZodRawShape>);
-    protected store(): Promise<STORE>;
-    protected validation(): Promise<VAL>;
-    protected shape(): Promise<ZodRawShape>;
+    constructor(name: string);
+    useStore(store: STORE): void;
+    useValidation(validation: VAL): void;
+    protected store(): STORE;
+    protected validation(): VAL;
 }

package/dist/api/IBackendApi.js

@@ -1,31 +1,24 @@
-import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
 export class IBackendApi {
     name;
-    storeC;
-    validationC;
-    shapeC;
     _store;
     _validation;
-    _shape;
-    constructor(name, storeC, validationC, shapeC) {
+    constructor(name) {
         this.name = name;
-        this.storeC = storeC;
-        this.validationC = validationC;
-        this.shapeC = shapeC;
     }
-    async store() {
+    useStore(store) {
+        this._store = store;
+    }
+    useValidation(validation) {
+        this._validation = validation;
+    }
+    store() {
         if (!this._store)
-            this._store = await callableUnwrap(this.storeC);
+            throw new Error(`${this.name}: store not provided. Use "useStore" method`);
         return this._store;
     }
-    async validation() {
+    validation() {
         if (!this._validation)
-            this._validation = await callableUnwrap(this.validationC);
+            throw new Error(`${this.name}: validation not provided. Use "useValidation" method`);
         return this._validation;
     }
-    async shape() {
-        if (!this._shape)
-            this._shape = await callableUnwrap(this.shapeC);
-        return this._shape;
-    }
 }

package/dist/function/IBackendFunction.d.ts

@@ -1,16 +1,16 @@
-import type { DocumentData, CallbackAble } from "@mxpicture/gcp-functions-common/types";
+import type { DocumentData } from "@mxpicture/gcp-functions-common/types";
 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>> {
-    protected apiC: CallbackAble<API>;
-    protected readonly routesC: CallbackAble<string[]>;
+export declare abstract class IBackendFunction<DTO extends DocumentData, API extends BackendApi<DTO>> {
+    readonly name: string;
     protected _api?: API;
     protected _routes?: string[];
-    protected constructor(apiC: CallbackAble<API>, routesC: CallbackAble<string[]>);
-    name(): Promise<string>;
-    protected api(): Promise<API>;
-    protected routes(): Promise<string[]>;
+    constructor(name: string);
+    useApi(api: API): void;
+    useRoutes(routes: string[]): void;
+    protected api(): API;
+    protected routes(): 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,35 +1,35 @@
 import { onCall, HttpsError, } from "firebase-functions/v2/https";
-import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
 export class IBackendFunction {
-    apiC;
-    routesC;
+    name;
     _api;
     _routes;
-    constructor(apiC, routesC) {
-        this.apiC = apiC;
-        this.routesC = routesC;
+    constructor(name) {
+        this.name = name;
     }
-    async name() {
-        return (await this.api()).name;
+    useApi(api) {
+        this._api = api;
     }
-    async api() {
+    useRoutes(routes) {
+        this._routes = routes;
+    }
+    api() {
         if (!this._api)
-            this._api = await callableUnwrap(this.apiC);
+            throw new Error(`${this.name}: api not provided. Use "useApi" method`);
         return this._api;
     }
-    async routes() {
+    routes() {
         if (!this._routes)
-            this._routes = await callableUnwrap(this.routesC);
+            throw new Error(`${this.name}: routes not provided. Use "useRoutes" method`);
         return this._routes;
     }
     async ingress(request) {
-        const routes = await this.routes();
+        const routes = this.routes();
         if (!routes.find((m) => m === request.route))
             throw new HttpsError("invalid-argument", `Route ${request.route} not available`);
         try {
             return {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                data: await (await this.api())[request.route](request.data),
+                data: await this.api()[request.route](request.data),
             };
         }
         catch (error) {

package/dist/validation/Validation.d.ts

@@ -1,16 +1,17 @@
 import { type ZodError, type ZodObject, type ZodRawShape } from "zod";
-import type { CallbackAble, DocumentData, WithKey, WithoutKey } from "@mxpicture/gcp-functions-common/types";
+import type { DocumentData, WithKey, WithoutKey } from "@mxpicture/gcp-functions-common/types";
 import { ValidationFieldErrors } from "../types/types.validation.js";
 export declare class Validation<DTO extends DocumentData> {
-    protected shapeC: CallbackAble<ZodRawShape>;
+    readonly name: string;
     protected _createSchema?: ZodObject;
     protected _updateSchema?: ZodObject;
     protected _shape?: ZodRawShape;
-    constructor(shapeC: CallbackAble<ZodRawShape>);
-    protected shape(): Promise<ZodRawShape>;
-    protected createSchema(): Promise<ZodObject>;
-    protected updateSchema(): Promise<ZodObject>;
-    validate(doc: Partial<WithoutKey<DTO>>): Promise<WithKey<DTO>>;
-    validatePartial(doc: Partial<WithKey<DTO>>): Promise<Partial<WithKey<DTO>>>;
+    constructor(name: string);
+    useShape(shape: ZodRawShape): void;
+    protected shape(): ZodRawShape;
+    protected createSchema(): ZodObject;
+    protected updateSchema(): ZodObject;
+    validate(doc: Partial<WithoutKey<DTO>>): WithKey<DTO>;
+    validatePartial(doc: Partial<WithKey<DTO>>): Partial<WithKey<DTO>>;
     protected issuesToFieldErrors(issues: ZodError["issues"]): ValidationFieldErrors;
 }

package/dist/validation/Validation.js

@@ -1,39 +1,41 @@
 import { z } from "zod";
 import { HttpsError } from "firebase-functions/https";
-import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
 export class Validation {
-    shapeC;
+    name;
     _createSchema;
     _updateSchema;
     _shape;
-    constructor(shapeC) {
-        this.shapeC = shapeC;
+    constructor(name) {
+        this.name = name;
     }
-    async shape() {
+    useShape(shape) {
+        this._shape = shape;
+    }
+    shape() {
         if (!this._shape)
-            this._shape = await callableUnwrap(this.shapeC);
+            throw new Error(`${this.name}: shape not provided. Use "useShape" method`);
         return this._shape;
     }
-    async createSchema() {
+    createSchema() {
         if (!this._createSchema)
-            this._createSchema = z.object(await this.shape());
+            this._createSchema = z.object(this.shape());
         return this._createSchema;
     }
-    async updateSchema() {
+    updateSchema() {
         if (!this._updateSchema)
-            this._updateSchema = (await this.createSchema()).partial();
+            this._updateSchema = this.createSchema().partial();
         return this._updateSchema;
     }
-    async validate(doc) {
-        const result = (await this.createSchema()).safeParse(doc);
+    validate(doc) {
+        const result = this.createSchema().safeParse(doc);
         if (!result.success)
             throw new HttpsError("invalid-argument", "Invalid request data", {
                 fields: this.issuesToFieldErrors(result.error.issues),
             });
         return result.data;
     }
-    async validatePartial(doc) {
-        const result = (await this.updateSchema()).safeParse(doc);
+    validatePartial(doc) {
+        const result = this.updateSchema().safeParse(doc);
         if (!result.success)
             throw new HttpsError("invalid-argument", "Invalid request data", {
                 fields: this.issuesToFieldErrors(result.error.issues),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxpicture/gcp-functions-backend",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "Utils for google cloud functions, publishing both CommonJS and ESM builds",
   "type": "module",
   "author": "MXPicture",
@@ -28,8 +28,7 @@
     "clean": "rm -rf dist .tsbuildinfo tsconfig.tsbuildinfo node_modules",
     "lint": "eslint \"src/**/*.{ts,tsx}\" --ext .ts,.tsx",
     "update": "ncu -u && npm install",
-    "build": "tsc -b .",
-    "update-own": "npm update --save @mxpicture/zod-meta"
+    "build": "tsc -b ."
   },
   "publishConfig": {
     "access": "public"
@@ -37,7 +36,6 @@
   "dependencies": {
     "@mxpicture/gcp-functions-common": "*",
     "@mxpicture/http-status-codes": "^0.1.28",
-    "@mxpicture/zod-meta": "^0.1.12",
     "cookie-parser": "^1.4.7",
     "express": "^5.2.1",
     "firebase-admin": "^13.6.0",
@@ -49,6 +47,8 @@
     "@types/cookie-parser": "^1.4.10",
     "@types/express": "^4.17.25",
     "@types/node": "^25.2.0",
+    "@typescript-eslint/eslint-plugin": "^8.55.0",
+    "@typescript-eslint/parser": "^8.55.0",
     "firebase-tools": "^15.5.1",
     "typescript": "^5.9.3"
   }