@mxpicture/gcp-functions-backend 0.1.34 → 0.1.43

package/dist/api/BackendApi.d.ts

@@ -1,32 +1,23 @@
 import type { MetaItem } from "@mxpicture/zod-meta";
-import type { ApiKey, ApiFilter, DocumentData, WithKey, CallbackAble } from "@mxpicture/gcp-functions-common/types";
-import { IApi } from "@mxpicture/gcp-functions-common/api";
+import type { DocumentData, WithKey, CallbackAble, 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";
-export declare class BackendApi<DTO extends DocumentData, STORE extends Store<DTO> = Store<DTO>, VAL extends Validation<DTO> = Validation<DTO>> extends IApi<DTO> {
-    protected readonly storeC: CallbackAble<STORE>;
-    protected readonly validationC: CallbackAble<VAL>;
-    protected readonly shapeC: CallbackAble<ZodRawShape>;
-    protected _store?: STORE;
-    protected _validation?: VAL;
-    protected _shape?: ZodRawShape;
+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>);
-    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>[]>;
-    count(payload?: ApiFilter): Promise<{
+    delete(request: DocumentKey): Promise<{
+        deleted: true;
+    }>;
+    get(request: DocumentKey): Promise<WithKey<DTO>>;
+    query(request?: ApiFilter | null): Promise<WithKey<DTO>[]>;
+    count(request?: ApiFilter | null): Promise<{
         count: number;
     }>;
-    exists(p: ApiKey): Promise<{
+    exists(request: DocumentKey): Promise<{
         exists: boolean;
     }>;
     meta(): Promise<MetaItem[]>;
-    create(data: DTO): Promise<WithKey<DTO>>;
-    update(p: {
-        id: string;
-    }, data: Partial<DTO>): Promise<WithKey<DTO>>;
+    create(request: WithoutKey<DTO>): Promise<WithKey<DTO>>;
+    update(request: WithKey<Partial<DTO>>): Promise<WithKey<DTO>>;
 }

package/dist/api/BackendApi.js

@@ -1,58 +1,34 @@
 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 {
-    storeC;
-    validationC;
-    shapeC;
-    _store;
-    _validation;
-    _shape;
+import { IBackendApi } from "./IBackendApi.js";
+export class BackendApi extends IBackendApi {
     constructor(storeC, validationC, shapeC) {
-        super();
-        this.storeC = storeC;
-        this.validationC = validationC;
-        this.shapeC = shapeC;
+        super(storeC, validationC, shapeC);
     }
-    async store() {
-        if (!this._store)
-            this._store = await callableUnwrap(this.storeC);
-        return this._store;
+    async delete(request) {
+        await (await this.store()).delete(request.id);
+        return { deleted: true };
     }
-    async validation() {
-        if (!this._validation)
-            this._validation = await callableUnwrap(this.validationC);
-        return this._validation;
+    async get(request) {
+        return (await this.store()).get(request.id);
     }
-    async shape() {
-        if (!this._shape)
-            this._shape = await callableUnwrap(this.shapeC);
-        return this._shape;
+    async query(request) {
+        return (await this.store()).query(request?.filters);
     }
-    async delete(p) {
-        return (await this.store()).delete(p.id);
+    async count(request) {
+        return { count: await (await this.store()).count(request?.filters) };
     }
-    async get(p) {
-        return (await this.store()).get(p.id);
-    }
-    async query(payload) {
-        return (await this.store()).query(payload?.filters);
-    }
-    async count(payload) {
-        return { count: await (await this.store()).count(payload?.filters) };
-    }
-    async exists(p) {
-        return { exists: await (await this.store()).exists(p.id) };
+    async exists(request) {
+        return { exists: await (await this.store()).exists(request.id) };
     }
     async meta() {
         return new Meta(await this.shape()).items();
     }
-    async create(data) {
-        const result = await (await this.validation()).validate(data);
+    async create(request) {
+        const result = await (await this.validation()).validate(request);
         return (await this.store()).create(result);
     }
-    async update(p, data) {
-        const result = await (await this.validation()).validatePartial(data);
-        return (await this.store()).update(p.id, result);
+    async update(request) {
+        const result = await (await this.validation()).validatePartial(request);
+        return (await this.store()).update(request.id, result);
     }
 }

package/dist/api/IBackendApi.d.ts

@@ -0,0 +1,16 @@
+import type { DocumentData, CallbackAble } 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>> {
+    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 store(): Promise<STORE>;
+    protected validation(): Promise<VAL>;
+    protected shape(): Promise<ZodRawShape>;
+}

package/dist/api/IBackendApi.js

@@ -0,0 +1,29 @@
+import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
+export class IBackendApi {
+    storeC;
+    validationC;
+    shapeC;
+    _store;
+    _validation;
+    _shape;
+    constructor(storeC, validationC, shapeC) {
+        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;
+    }
+}

package/dist/api/index.d.ts

@@ -1 +1,2 @@
 export { BackendApi } from "./BackendApi.js";
+export { IBackendApi } from "./IBackendApi.js";

package/dist/api/index.js

@@ -1 +1,2 @@
 export { BackendApi } from "./BackendApi.js";
+export { IBackendApi } from "./IBackendApi.js";

package/dist/function/BackendFunction.d.ts

@@ -1,11 +1,22 @@
-import { CallableFunction } from "firebase-functions/https";
-import type { HttpHandlers, DocumentData, WithKey, ApiRoutes, FunctionPayload, FunctionResult, 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 httpC: CallbackAble<HANDLER>;
-    protected readonly httpMethods: string[];
-    protected _http?: HANDLER;
-    constructor(name: string, httpC: CallbackAble<HANDLER>);
-    protected http(): Promise<HANDLER>;
-    createFunction(): CallableFunction<FunctionPayload<DTO>, Promise<FunctionResult<WithKey<DTO>>>>;
+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>);
+    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[]>>;
 }

package/dist/function/BackendFunction.js

@@ -1,29 +1,31 @@
-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;
-    httpC;
-    httpMethods;
-    _http;
-    constructor(name, httpC) {
-        this.name = name;
-        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(async (req) => {
-            if (!this.httpMethods.find((m) => m === req.data.route))
-                throw new HttpsError("invalid-argument", `Route ${req.data.route} not available`);
-            return {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                doc: await (await this.http())[req.data.route](req.data),
-            };
-        });
+import { IBackendFunction } from "./IBackendFunction.js";
+import { CRUD_ROUTES } from "@mxpicture/gcp-functions-common/config";
+export class BackendFunction extends IBackendFunction {
+    constructor(name, apiC) {
+        super(name, apiC, CRUD_ROUTES);
+    }
+    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 });
     }
 }

package/dist/function/IBackendFunction.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentData, CallbackAble } 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>> {
+    readonly name: string;
+    protected apiC: CallbackAble<API>;
+    protected readonly routes: string[];
+    protected _api?: API;
+    protected constructor(name: string, apiC: CallbackAble<API>, routes: string[]);
+    protected api(): Promise<API>;
+    ingress<REQ, RES extends DocumentData>(request: FunctionRequest<REQ>): Promise<FunctionResponse<RES>>;
+    buildFunction(): CallableFunction<FunctionRequest<any>, Promise<FunctionResponse<any>>>;
+}

package/dist/function/IBackendFunction.js

@@ -0,0 +1,38 @@
+import { onCall, HttpsError, } from "firebase-functions/v2/https";
+import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
+export class IBackendFunction {
+    name;
+    apiC;
+    routes;
+    _api;
+    constructor(name, apiC, routes) {
+        this.name = name;
+        this.apiC = apiC;
+        this.routes = routes;
+    }
+    async api() {
+        if (!this._api)
+            this._api = await callableUnwrap(this.apiC);
+        return this._api;
+    }
+    async ingress(request) {
+        if (!this.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),
+            };
+        }
+        catch (error) {
+            if (error instanceof HttpsError)
+                throw error;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            throw new HttpsError("internal", error?.message ?? "unknown");
+            // }
+        }
+    }
+    buildFunction() {
+        return onCall(async (req) => this.ingress(req.data));
+    }
+}

package/dist/function/index.d.ts

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

package/dist/function/index.js

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

package/dist/store/Store.d.ts

@@ -1,5 +1,5 @@
 import type { CollectionReference, DocumentReference, FirestoreDataConverter, Query, QuerySnapshot } from "firebase-admin/firestore";
-import type { DocumentData, WithKey, ApiFilterItems } from "@mxpicture/gcp-functions-common/types";
+import type { ApiFilterItems, DocumentData, WithKey } from "@mxpicture/gcp-functions-common/types";
 export declare class Store<DTO extends DocumentData> {
     readonly collectionName: string;
     protected readonly converter?: FirestoreDataConverter<DTO> | undefined;

package/dist/validation/Validation.d.ts

@@ -1,5 +1,5 @@
-import type { ZodError, ZodObject, ZodRawShape } from "zod";
-import type { CallbackAble, DocumentData, WithKey } from "@mxpicture/gcp-functions-common/types";
+import { type ZodError, type ZodObject, type ZodRawShape } from "zod";
+import type { CallbackAble, 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>;
@@ -10,7 +10,7 @@ export declare class Validation<DTO extends DocumentData> {
     protected shape(): Promise<ZodRawShape>;
     protected createSchema(): Promise<ZodObject>;
     protected updateSchema(): Promise<ZodObject>;
-    validate(doc: Partial<WithKey<DTO>>): Promise<WithKey<DTO>>;
+    validate(doc: Partial<WithoutKey<DTO>>): Promise<WithKey<DTO>>;
     validatePartial(doc: Partial<WithKey<DTO>>): Promise<Partial<WithKey<DTO>>>;
     protected issuesToFieldErrors(issues: ZodError["issues"]): ValidationFieldErrors;
 }

package/dist/validation/Validation.js

@@ -1,5 +1,5 @@
+import { z } from "zod";
 import { HttpsError } from "firebase-functions/https";
-import { loadZod } from "../loader/zod.loader.js";
 import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
 export class Validation {
     shapeC;
@@ -16,7 +16,7 @@ export class Validation {
     }
     async createSchema() {
         if (!this._createSchema)
-            this._createSchema = (await loadZod()).object(await this.shape());
+            this._createSchema = z.object(await this.shape());
         return this._createSchema;
     }
     async updateSchema() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxpicture/gcp-functions-backend",
-  "version": "0.1.34",
+  "version": "0.1.43",
   "description": "Utils for google cloud functions, publishing both CommonJS and ESM builds",
   "type": "module",
   "author": "MXPicture",
@@ -14,7 +14,6 @@
     "./firebase": "./dist/firebase/index.js",
     "./validation": "./dist/validation/index.js",
     "./api": "./dist/api/index.js",
-    "./http": "./dist/http/index.js",
     "./function": "./dist/function/index.js",
     "./types": "./dist/types/index.js",
     "./package.json": "./package.json"

package/dist/function/FunctionCollection.d.ts

@@ -1,11 +0,0 @@
-import { HttpsFunction } from "firebase-functions/https";
-import { BackendFunction } from "./BackendFunction.js";
-import type { DocumentData } from "@mxpicture/gcp-functions-common/types";
-export declare class FunctionCollection {
-    protected funcs: {
-        [key: string]: BackendFunction<any>;
-    };
-    constructor();
-    add<DTO extends DocumentData>(func: BackendFunction<DTO>, name?: string): FunctionCollection;
-    build(): Record<string, HttpsFunction>;
-}

package/dist/function/FunctionCollection.js

@@ -1,15 +0,0 @@
-export class FunctionCollection {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    funcs = {};
-    constructor() { }
-    add(func, name) {
-        this.funcs[name ?? func.name] = func;
-        return this;
-    }
-    build() {
-        const r = {};
-        for (const [key, func] of Object.entries(this.funcs))
-            r[key] = func.createFunction();
-        return r;
-    }
-}

package/dist/http/BackendHttp.d.ts

@@ -1,20 +0,0 @@
-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 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>[]>;
-    count(req: FunctionPayload<ApiFilter>): Promise<{
-        count: number;
-    }>;
-    exists(req: FunctionPayload<never, ApiKey>): Promise<{
-        exists: boolean;
-    }>;
-    meta(): Promise<import("@mxpicture/zod-meta").MetaItem[]>;
-    create(req: FunctionPayload<DTO>): Promise<import("@mxpicture/gcp-functions-common/types").WithKey<DTO>>;
-    update(req: FunctionPayload<Partial<DTO>, ApiKey>): Promise<import("@mxpicture/gcp-functions-common/types").WithKey<DTO>>;
-}

package/dist/http/BackendHttp.js

@@ -1,110 +0,0 @@
-import { HttpsError } from "firebase-functions/https";
-import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
-export class BackendHttp {
-    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 (await this.api()).delete({ id });
-        }
-        catch (error) {
-            if (error instanceof HttpsError)
-                throw error;
-            throw new HttpsError("not-found", `Id ${req.keys?.id} not found`);
-        }
-    }
-    async get(req) {
-        try {
-            const id = req.keys?.id;
-            if (!id)
-                throw new HttpsError("invalid-argument", "Id invalid");
-            return (await this.api()).get({ id });
-        }
-        catch (error) {
-            if (error instanceof HttpsError)
-                throw error;
-            throw new HttpsError("not-found", `Id ${req.keys?.id} not found`);
-        }
-    }
-    async query(req) {
-        try {
-            return (await this.api()).query(req.content);
-        }
-        catch (error) {
-            if (error instanceof HttpsError)
-                throw error;
-            throw new HttpsError("unknown", "Unknown error");
-        }
-    }
-    async count(req) {
-        try {
-            return (await this.api()).count(req.content);
-        }
-        catch (error) {
-            if (error instanceof HttpsError)
-                throw error;
-            throw new HttpsError("unknown", "Unknown error");
-        }
-    }
-    async exists(req) {
-        try {
-            const id = req.keys?.id;
-            if (!id)
-                throw new HttpsError("invalid-argument", "Id invalid");
-            return await (await this.api()).exists({ id });
-        }
-        catch (error) {
-            if (error instanceof HttpsError)
-                throw error;
-            throw new HttpsError("unknown", "Unknown error");
-        }
-    }
-    async meta() {
-        try {
-            return (await this.api()).meta();
-        }
-        catch (error) {
-            if (error instanceof HttpsError)
-                throw error;
-            throw new HttpsError("unknown", "Unknown error");
-        }
-    }
-    async create(req) {
-        try {
-            if (!req.content)
-                throw new HttpsError("invalid-argument", "Content is invalid");
-            return (await this.api()).create(req.content);
-        }
-        catch (error) {
-            if (error instanceof HttpsError)
-                throw error;
-            throw new HttpsError("unknown", "Unknown error");
-        }
-    }
-    async update(req) {
-        try {
-            const id = req.keys?.id;
-            if (!id)
-                throw new HttpsError("invalid-argument", "Id invalid");
-            if (!req.content)
-                throw new HttpsError("invalid-argument", "Content is invalid");
-            return (await this.api()).update({ id }, req.content);
-        }
-        catch (error) {
-            if (error instanceof HttpsError)
-                throw error;
-            throw new HttpsError("unknown", "Unknown error");
-        }
-    }
-}

package/dist/http/index.d.ts

@@ -1 +0,0 @@
-export { BackendHttp } from "./BackendHttp.js";

package/dist/http/index.js

@@ -1 +0,0 @@
-export { BackendHttp } from "./BackendHttp.js";

package/dist/loader/zod.loader.d.ts

@@ -1 +0,0 @@
-export declare const loadZod: () => Promise<typeof import("zod")>;

package/dist/loader/zod.loader.js

@@ -1,6 +0,0 @@
-let zodPromise = null;
-export const loadZod = () => {
-    if (!zodPromise)
-        zodPromise = import("zod");
-    return zodPromise;
-};