@mxpicture/gcp-functions-frontend 0.1.32 → 0.1.42

package/dist/api/FrontendApi.d.ts

@@ -1,25 +1,21 @@
 import type { MetaItem } from "@mxpicture/zod-meta";
-import type { ApiKey, DocumentData, WithKey, FunctionPayload, FunctionResult } from "@mxpicture/gcp-functions-common/types";
-import { IApi } from "@mxpicture/gcp-functions-common/api";
-import { type HttpsCallable } from "firebase/functions";
-export declare const functionCallable: <DTO extends DocumentData, KEYS extends ApiKey>(name: string) => Promise<HttpsCallable<FunctionPayload<DTO, KEYS>, FunctionResult<WithKey<DTO>>, unknown>>;
-export declare class FrontendApi<DTO extends DocumentData> extends IApi<DTO> {
-    readonly name: string;
-    protected _service?: HttpsCallable<FunctionPayload<DTO, ApiKey>, FunctionResult<WithKey<DTO>>, unknown>;
-    constructor(name: string);
-    protected service(): Promise<HttpsCallable<FunctionPayload<DTO, ApiKey>, FunctionResult<WithKey<DTO>>, unknown>>;
-    delete(keys: ApiKey): Promise<void>;
-    get(keys: ApiKey): Promise<WithKey<DTO>>;
-    query(): Promise<WithKey<DTO>[]>;
-    count(): Promise<{
+import type { DocumentData, WithKey, CallbackAble, ApiFromRoutes, CrudRoutes, WithoutKey, DocumentKey, ApiFilter } from "@mxpicture/gcp-functions-common/types";
+import { IFrontendApi } from "./IFrontendApi.js";
+import { FrontendFunction } from "../function/FrontendFunction.js";
+export declare class FrontendApi<DTO extends DocumentData, FUNC extends FrontendFunction<DTO>> extends IFrontendApi<DTO, FUNC> implements ApiFromRoutes<CrudRoutes<DTO>> {
+    constructor(funcC: CallbackAble<FUNC>);
+    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(keys: ApiKey): Promise<{
+    exists(request: DocumentKey): Promise<{
         exists: boolean;
     }>;
     meta(): Promise<MetaItem[]>;
-    create(data: DTO): Promise<WithKey<DTO>>;
-    update(keys: {
-        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/FrontendApi.js

@@ -1,55 +1,30 @@
-import { IApi } from "@mxpicture/gcp-functions-common/api";
-import { httpsCallable } from "firebase/functions";
-import { configFirebase } from "../config/firebase.config.js";
-export const functionCallable = async (name) => {
-    return httpsCallable((await configFirebase()).functions, name);
-};
-export class FrontendApi extends IApi {
-    name;
-    _service;
-    constructor(name) {
-        super();
-        this.name = name;
-    }
-    async service() {
-        if (!this._service)
-            this._service = await functionCallable(this.name);
-        return this._service;
-    }
-    async delete(keys) {
-        await (await this.service())({ route: "delete", keys });
-    }
-    async get(keys) {
-        return (await (await this.service())({ route: "get", keys })).data
-            .doc;
-    }
-    // todo add filter
-    async query() {
-        return (await (await this.service())({ route: "query" })).data
-            .doc;
-    }
-    async count() {
-        return (await (await this.service())({ route: "count" })).data
-            .doc;
-    }
-    async exists(keys) {
-        return (await (await this.service())({ route: "exists", keys })).data
-            .doc;
+import { IFrontendApi } from "./IFrontendApi.js";
+export class FrontendApi extends IFrontendApi {
+    constructor(funcC) {
+        super(funcC);
+    }
+    async delete(request) {
+        return (await (await this.func()).delete(request)).data;
+    }
+    async get(request) {
+        return (await (await this.func()).get(request)).data;
+    }
+    async query(request) {
+        return (await (await this.func()).query(request)).data;
+    }
+    async count(request) {
+        return (await (await this.func()).count(request)).data;
+    }
+    async exists(request) {
+        return (await (await this.func()).exists(request)).data;
     }
     async meta() {
-        // return new Meta(this.shape).items();
-        // todo
-        return [];
-    }
-    async create(data) {
-        return (await (await this.service())({ route: "create", content: data }))
-            .data.doc;
-    }
-    async update(keys, data) {
-        return (await (await this.service())({
-            route: "update",
-            keys,
-            content: data,
-        })).data.doc;
+        return (await (await this.func()).meta()).data;
+    }
+    async create(request) {
+        return (await (await this.func()).create(request)).data;
+    }
+    async update(request) {
+        return (await (await this.func()).update(request)).data;
     }
 }

package/dist/api/IFrontendApi.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentData, CallbackAble } from "@mxpicture/gcp-functions-common/types";
+import { FrontendFunction } from "../function/FrontendFunction.js";
+export declare class IFrontendApi<DTO extends DocumentData, FUNC extends FrontendFunction<DTO>> {
+    protected funcC: CallbackAble<FUNC>;
+    protected _func?: FUNC;
+    protected constructor(funcC: CallbackAble<FUNC>);
+    protected func(): Promise<FUNC>;
+}

package/dist/api/IFrontendApi.js

@@ -0,0 +1,13 @@
+import { callableUnwrap } from "@mxpicture/gcp-functions-common/helper";
+export class IFrontendApi {
+    funcC;
+    _func;
+    constructor(funcC) {
+        this.funcC = funcC;
+    }
+    async func() {
+        if (!this._func)
+            this._func = await callableUnwrap(this.funcC);
+        return this._func;
+    }
+}

package/dist/api/index.d.ts

@@ -1 +1,2 @@
-export { FrontendApi, functionCallable } from "./FrontendApi.js";
+export { FrontendApi } from "./FrontendApi.js";
+export { IFrontendApi } from "./IFrontendApi.js";

package/dist/api/index.js

@@ -1 +1,2 @@
-export { FrontendApi, functionCallable } from "./FrontendApi.js";
+export { FrontendApi } from "./FrontendApi.js";
+export { IFrontendApi } from "./IFrontendApi.js";

package/dist/config/firebase.config.d.ts

@@ -2,15 +2,15 @@ import { GoogleAuthProvider, type Auth } from "firebase/auth";
 import { type FirebaseApp } from "firebase/app";
 import { type Functions } from "firebase/functions";
 import type { FirebaseConfig, FirebaseEmulatorConfig } from "../types/firebase.types.js";
-export declare const initializeFirebase: (config: FirebaseConfig, emu?: FirebaseEmulatorConfig) => Promise<{
+export declare const initializeFirebase: (config: FirebaseConfig, emu?: FirebaseEmulatorConfig) => {
     app: FirebaseApp;
     auth: Auth;
     functions: Functions;
     googleProvider: GoogleAuthProvider;
-}>;
-export declare const configFirebase: () => Promise<{
+};
+export declare const configFirebase: () => {
     app: FirebaseApp;
     auth: Auth;
     functions: Functions;
     googleProvider: GoogleAuthProvider;
-}>;
+};

package/dist/config/firebase.config.js

@@ -4,7 +4,7 @@ import { connectFunctionsEmulator, getFunctions, } from "firebase/functions";
 let _inst = null;
 let _config = null;
 let _emu = null;
-export const initializeFirebase = async (config, emu) => {
+export const initializeFirebase = (config, emu) => {
     if (_config)
         throw new Error("Firebase config already present");
     _config = { ...config };
@@ -12,7 +12,7 @@ export const initializeFirebase = async (config, emu) => {
         _emu = { ...emu };
     return configFirebase();
 };
-export const configFirebase = async () => {
+export const configFirebase = () => {
     if (!_inst) {
         if (!_config)
             throw new Error("Firebase config not provided. Use initializeFirebase at first");

package/dist/function/FrontendFunction.d.ts

@@ -0,0 +1,20 @@
+import type { DocumentData, CrudRoutes, FunctionFromRoutes, ApiFilter, DocumentKey, FunctionResponse, WithKey, WithoutKey } from "@mxpicture/gcp-functions-common/types";
+import { IFrontendFunction } from "./IFrontendFunction.js";
+import { MetaItem } from "@mxpicture/zod-meta";
+export declare class FrontendFunction<DTO extends DocumentData> extends IFrontendFunction implements FunctionFromRoutes<CrudRoutes<DTO>> {
+    constructor(name: 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[]>>;
+}

package/dist/function/FrontendFunction.js

@@ -0,0 +1,31 @@
+import { IFrontendFunction } from "./IFrontendFunction.js";
+import { CRUD_ROUTES } from "@mxpicture/gcp-functions-common/config";
+export class FrontendFunction extends IFrontendFunction {
+    constructor(name) {
+        super(name, CRUD_ROUTES);
+    }
+    async create(request) {
+        return this.outgress({ data: request, route: "create" });
+    }
+    async update(request) {
+        return this.outgress({ data: request, route: "update" });
+    }
+    async delete(request) {
+        return this.outgress({ data: request, route: "delete" });
+    }
+    async get(request) {
+        return this.outgress({ data: request, route: "get" });
+    }
+    async query(request) {
+        return this.outgress({ data: request, route: "query" });
+    }
+    async count(request) {
+        return this.outgress({ data: request, route: "count" });
+    }
+    async exists(request) {
+        return this.outgress({ data: request, route: "exists" });
+    }
+    async meta() {
+        return this.outgress({ data: null, route: "meta" });
+    }
+}

package/dist/function/IFrontendFunction.d.ts

@@ -0,0 +1,10 @@
+import type { DocumentData, FunctionRequest, FunctionResponse } from "@mxpicture/gcp-functions-common/types";
+import { HttpsCallable } from "firebase/functions";
+export declare class IFrontendFunction {
+    readonly name: string;
+    protected readonly routes: string[];
+    protected _func?: HttpsCallable<FunctionRequest<any>, Promise<FunctionResponse<any>>, unknown>;
+    protected constructor(name: string, routes: string[]);
+    outgress<REQ, RES extends DocumentData>(request: FunctionRequest<REQ>): Promise<FunctionResponse<RES>>;
+    protected func(): HttpsCallable<FunctionRequest<any>, Promise<FunctionResponse<any>>, unknown>;
+}

package/dist/function/IFrontendFunction.js

@@ -0,0 +1,21 @@
+import { httpsCallable } from "firebase/functions";
+import { configFirebase } from "../config/firebase.config.js";
+export class IFrontendFunction {
+    name;
+    routes;
+    _func;
+    constructor(name, routes) {
+        this.name = name;
+        this.routes = routes;
+    }
+    async outgress(request) {
+        if (!this.routes.find((m) => m === request.route))
+            throw new Error(`Route ${request.route} not available`);
+        return (await this.func()(request)).data;
+    }
+    func() {
+        if (!this._func)
+            this._func = httpsCallable(configFirebase().functions, this.name);
+        return this._func;
+    }
+}

package/dist/function/index.d.ts

@@ -0,0 +1,2 @@
+export { FrontendFunction } from "./FrontendFunction.js";
+export { IFrontendFunction } from "./IFrontendFunction.js";

package/dist/function/index.js

@@ -0,0 +1,2 @@
+export { FrontendFunction } from "./FrontendFunction.js";
+export { IFrontendFunction } from "./IFrontendFunction.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxpicture/gcp-functions-frontend",
-  "version": "0.1.32",
+  "version": "0.1.42",
   "description": "Utils for google cloud functions, publishing both CommonJS and ESM builds",
   "type": "module",
   "author": "MXPicture",
@@ -15,13 +15,14 @@
     "./types": "./dist/types/index.js",
     "./api": "./dist/api/index.js",
     "./helper": "./dist/helper/index.js",
+    "./function": "./dist/function/index.js",
     "./package.json": "./package.json"
   },
   "files": [
     "dist"
   ],
   "engines": {
-    "node": "24"
+    "node": ">=22"
   },
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo tsconfig.tsbuildinfo node_modules",
@@ -35,7 +36,7 @@
   },
   "dependencies": {
     "@mxpicture/gcp-functions-common": "*",
-    "@mxpicture/zod-meta": "^0.1.7",
+    "@mxpicture/zod-meta": "^0.1.12",
     "firebase": "^12.8.0"
   },
   "devDependencies": {