@mxpicture/gcp-functions 0.1.0

package/dist/esm/handler/IHttpHandlerItem.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IHttpHandlerItem = void 0;
+const raw_body_1 = __importDefault(require("raw-body"));
+const http_js_1 = require("../common/http.js");
+const https_1 = require("firebase-functions/v2/https");
+const zod_1 = require("zod");
+const types_common_js_1 = require("../common/types.common.js");
+const http_status_codes_1 = require("@mxpicture/http-status-codes");
+// export interface HandlerEnv {
+//   connectionToken: () => string;
+// }
+class IHttpHandlerItem {
+    constructor(name, api) {
+        this.name = name;
+        this.api = api;
+        this.corsAllowList = [];
+    }
+    setup(exp) {
+        exp.get(`/api/${this.name}`, async (req, res) => {
+            try {
+                const items = await this.api.query();
+                return this.httpSuccess(res, items);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+        exp.get(`/api/${this.name}_meta`, async (req, res) => {
+            try {
+                const items = this.api.metaItems();
+                return this.httpSuccess(res, items);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+        exp.get(`/api/${this.name}/:id`, async (req, res) => {
+            try {
+                const item = await this.api.get(req.params.id);
+                return this.httpSuccess(res, item);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+        exp.post(`/api/${this.name}`, async (req, res) => {
+            try {
+                const item = await this.extractBodyItem(req);
+                const valResult = await this.api.validate(item);
+                if (!valResult.success)
+                    throw (0, zod_1.treeifyError)(valResult.error);
+                const validated = await this.api.create(valResult.data);
+                return this.httpSuccess(res, validated);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+        exp.patch(`/api/${this.name}/:id`, async (req, res) => {
+            try {
+                const item = await this.extractBodyItem(req);
+                const valResult = await this.api.validatePartial(item);
+                if (!valResult.success)
+                    throw (0, zod_1.treeifyError)(valResult.error);
+                const validated = await this.api.updatePartial(req.params.id, valResult.data);
+                return this.httpSuccess(res, validated);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+    }
+    httpSuccess(res, payload, statusCode = http_status_codes_1.StatusCodes.OK) {
+        const result = { statusCode, payload };
+        return res.status(statusCode).json(result);
+    }
+    httpError(res, errors, statusCode = http_status_codes_1.StatusCodes.BAD_REQUEST) {
+        const result = { statusCode, errors };
+        return res.status(statusCode).json(result);
+    }
+    httpErrorUnnown(res, error, statusCode = http_status_codes_1.StatusCodes.BAD_REQUEST) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ae = error;
+        const messages = [];
+        if (error instanceof Error) {
+            messages.push({ message: error.message });
+        }
+        else if (typeof error === "string") {
+            messages.push({ message: error });
+        }
+        else if (ae.message) {
+            const err = (0, types_common_js_1.castHttpError)(ae.message);
+            if (err)
+                messages.push(err);
+        }
+        else if (ae.errors) {
+            messages.push(...this.extractZodError(ae));
+        }
+        else if (ae.payload) {
+            if (ae.payload.message && typeof ae.payload.message === "string")
+                messages.push({ message: ae.payload.message });
+            else if (typeof ae.payload === "string")
+                messages.push({ message: ae.payload });
+        }
+        else {
+            messages.push({ message: "unknown" });
+        }
+        return this.httpError(res, messages, statusCode);
+    }
+    extractZodError(tree, ...contexts) {
+        const errors = tree.errors?.map((e) => ({
+            message: e,
+            context: this.contextPath(...contexts),
+        })) ?? [];
+        const items = "items" in tree && tree.items
+            ? tree.items
+            : "properties" in tree && tree.properties
+                ? tree.properties
+                : [];
+        if (Array.isArray(items)) {
+            for (let i = 0; i < items.length; i++)
+                errors.push(...this.extractZodError(items[i], ...contexts, i));
+        }
+        else {
+            for (const [key, item] of Object.entries(items))
+                errors.push(...this.extractZodError(item, ...contexts, key));
+        }
+        return errors;
+    }
+    contextPath(...parts) {
+        const ps = parts
+            .filter((p) => !!p)
+            .map((p) => (typeof p === "string" ? p : `${p}`));
+        return ps.join(".");
+    }
+    createFunction(exp) {
+        return (0, https_1.onRequest)({ cors: [/firebase\.com$/, /web\.app$/] }, exp);
+    }
+    async extractBody(req) {
+        if (!req.headers["content-type"])
+            throw new Error("No content type provided");
+        const body = req.body ??
+            JSON.parse(await (0, raw_body_1.default)((0, http_js_1.contentstream)(req, false), {
+                encoding: "utf-8",
+            }));
+        if (Array.isArray(body))
+            return body;
+        if (body && Object.keys(body).length > 0)
+            return body;
+        throw new Error("Invalid / not existing body");
+    }
+    async extractBodyItem(req) {
+        const extr = await this.extractBody(req);
+        if (!extr || Array.isArray(extr))
+            throw new Error(`No item found in body`);
+        return extr;
+    }
+    async extractBodyItems(req) {
+        const extr = await this.extractBody(req);
+        if (!extr || !Array.isArray(extr))
+            throw new Error(`No items found in body`);
+        return extr;
+    }
+}
+exports.IHttpHandlerItem = IHttpHandlerItem;

package/dist/esm/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+// A default export can help some consumers using require()
+const _all = __importStar(require("./lib"));
+exports.default = _all;

package/dist/esm/lib.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FunctionHandlers"), exports);
+__exportStar(require("./handler/IHttpHandlerItem"), exports);
+__exportStar(require("./handler/HttpHandler"), exports);
+__exportStar(require("./common/firebase"), exports);
+__exportStar(require("./common/http"), exports);
+__exportStar(require("./common/types.common"), exports);
+__exportStar(require("./api/IApi"), exports);
+__exportStar(require("./store/IStore"), exports);
+__exportStar(require("./store/types.store"), exports);

package/dist/esm/package.js

@@ -0,0 +1,21 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./types/express.d.ts" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export your public types/exports so this file becomes the root .d.ts for the package.
+// Adjust the relative path if your source layout differs.
+__exportStar(require("./lib"), exports);

package/dist/esm/store/IStore.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IStore = exports.convertDocObject = void 0;
+const firebase_js_1 = require("../common/firebase.js");
+const uuid = __importStar(require("short-uuid"));
+const convertDocObject = (doc) => {
+    if (typeof doc.data !== "function")
+        return doc;
+    return {
+        ...doc.data(),
+        createTime: doc.createTime,
+        updateTime: doc.updateTime,
+        id: doc.id,
+    };
+};
+exports.convertDocObject = convertDocObject;
+class IStore {
+    constructor(collectionName) {
+        this.collectionName = collectionName;
+    }
+    db() {
+        if (!this._db)
+            this._db = firebase_js_1.db
+                .collection(`picpad.${this.collectionName}`)
+                .withConverter(this.createConverter());
+        return this._db;
+    }
+    async query(p) {
+        const snapshot = p && p.parentId
+            ? await this.refByParent(p.parentId).get()
+            : await this.db().get();
+        return snapshot.docs.map((exports.convertDocObject));
+    }
+    async count(p) {
+        const snapshot = p && p.parentId
+            ? await this.refByParent(p.parentId).count().get()
+            : await this.db().count().get();
+        return snapshot.data().count;
+    }
+    ref(id) {
+        return this.db().doc(id);
+    }
+    async get(id) {
+        const snapshot = await this.ref(id).get();
+        if (!snapshot.exists)
+            throw new Error(`Id ${id} does not exist`);
+        return (0, exports.convertDocObject)(snapshot);
+    }
+    async exists(id) {
+        return (await this.ref(id).get()).exists;
+    }
+    async create(doc) {
+        doc.id = uuid.generate();
+        const ref = this.ref(doc.id);
+        await ref.set(doc);
+        return this.get(doc.id);
+    }
+    async update(id, doc) {
+        const entry = this.ref(id);
+        await entry.update({ ...doc });
+        return this.get(id);
+    }
+    async delete(...ids) {
+        await Promise.all(ids.map((id) => this.ref(id).delete()));
+    }
+    async deleteByParent(parentId) {
+        const snapshot = await this.refByParent(parentId).get();
+        await this.delete(...snapshot.docs.map((doc) => doc.id));
+    }
+    refByParent(parentId) {
+        return this.db().where("parentId", "==", parentId);
+    }
+}
+exports.IStore = IStore;

package/dist/esm/store/types.store.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storePersistSchema = exports.storeBaseSchema = exports.storePersistSchemaShape = exports.storeBaseSchemaShape = void 0;
+const zod_1 = require("zod");
+exports.storeBaseSchemaShape = {
+    id: zod_1.z.string().optional(),
+    createTime: zod_1.z.date().optional(),
+    updateTime: zod_1.z.date().optional(),
+};
+exports.storePersistSchemaShape = {
+    ...exports.storeBaseSchemaShape,
+    id: zod_1.z.string(),
+};
+exports.storeBaseSchema = zod_1.z.object(exports.storeBaseSchemaShape);
+exports.storePersistSchema = zod_1.z.object(exports.storePersistSchemaShape);

package/dist/types/FunctionHandlers.d.ts

@@ -0,0 +1,12 @@
+import { HttpsFunction } from "firebase-functions/v2/https";
+import { HttpHandler } from "./handler/HttpHandler.js";
+export declare class FunctionHandlers {
+    protected items: {
+        [name: string]: HttpHandler;
+    };
+    constructor();
+    add(handler: HttpHandler): void;
+    functions(): {
+        [name: string]: HttpsFunction;
+    };
+}

package/dist/types/api/IApi.d.ts

@@ -0,0 +1,27 @@
+import { ZodRawShape, ZodSafeParseResult } from "zod";
+import { IStore } from "../store/IStore.js";
+import { StoreBaseDoc, StorePersistDoc } from "../store/types.store.js";
+import { MetaItem } from "@mxpicture/zod-meta";
+export type AdditionalParams = {
+    [key: string]: string;
+};
+export declare abstract class IApi<DOC extends StoreBaseDoc, STORE_DOC extends StorePersistDoc> {
+    protected store: IStore<DOC, STORE_DOC>;
+    protected shape: ZodRawShape;
+    constructor(store: IStore<DOC, STORE_DOC>, shape: ZodRawShape);
+    abstract validate(doc: Partial<DOC>): Promise<ZodSafeParseResult<DOC>>;
+    abstract validatePartial(doc: Partial<DOC>): Promise<ZodSafeParseResult<Partial<DOC>>>;
+    abstract toStore(doc: DOC): Promise<STORE_DOC>;
+    abstract toStorePartial(doc: Partial<DOC>): Promise<Partial<STORE_DOC>>;
+    abstract fromStore(store: STORE_DOC): Promise<DOC>;
+    abstract fromStorePartial(store: Partial<STORE_DOC>): Promise<Partial<DOC>>;
+    metaItems(): MetaItem[];
+    create(doc: DOC, params?: AdditionalParams): Promise<DOC>;
+    get(id: string, params?: AdditionalParams): Promise<DOC>;
+    query(params?: AdditionalParams): Promise<DOC[]>;
+    count(params?: AdditionalParams): Promise<number>;
+    update(id: string, doc: DOC, params?: AdditionalParams): Promise<DOC>;
+    updatePartial(id: string, doc: Partial<DOC>): Promise<DOC>;
+    delete(id: string, params?: AdditionalParams): Promise<void>;
+    exists(id: string, params?: AdditionalParams): Promise<boolean>;
+}

package/dist/types/common/firebase.d.ts

@@ -0,0 +1,11 @@
+import * as express from "express";
+export declare const app: import("firebase-admin/app").App;
+export declare const db: FirebaseFirestore.Firestore;
+export declare const extractToken: (request: express.Request) => string | undefined;
+export declare const verifyToken: (request: express.Request, response: express.Response, next: express.NextFunction) => void;
+export declare const verifySessionCookie: (request: express.Request, response: express.Response, next: express.NextFunction) => void;
+export declare const verifyAuthAll: (token: () => string) => (request: express.Request, response: express.Response, next: express.NextFunction) => void | express.Response<any, Record<string, any>>;
+export declare const sessionLogin: (request: express.Request, response: express.Response) => void;
+export declare const sessionLogout: (request: express.Request, response: express.Response) => void;
+export declare const verifyConnectionToken: (token: () => string) => (request: express.Request, response: express.Response, next: express.NextFunction) => Promise<void>;
+export declare const round: (value: number, digits?: number) => number;

package/dist/types/common/http.d.ts

@@ -0,0 +1,20 @@
+import * as express from "express";
+import * as http from "http";
+import { Inflate, Deflate, Gunzip, BrotliDecompress } from "zlib";
+import { DocumentData } from "./types.common.js";
+export type Streams = Inflate | Gunzip | Deflate | BrotliDecompress | http.IncomingMessage;
+/**
+ * Get the content stream of the request.
+ *
+ * @param {object} req
+ * @param {function} debug
+ * @param {boolean} [inflate=true]
+ * @return {object}
+ * @api private
+ */
+export declare const contentstream: (req: express.Request, inflate: boolean, debug?: Console) => Streams;
+export declare const hasBody: (request: http.IncomingMessage) => boolean;
+/**
+ * Fix proxied body if bodyParser is involved.
+ */
+export declare const fixRequestBody: (proxyReq: http.ClientRequest, requestBody: DocumentData | DocumentData[] | undefined) => void;

package/dist/types/common/types.common.d.ts

@@ -0,0 +1,31 @@
+export declare enum HttpProtocol {
+    http = "http",
+    https = "https"
+}
+export declare enum HttpMethod {
+    POST = "POST",
+    PATCH = "PATCH",
+    PUT = "PUT",
+    GET = "GET",
+    DELETE = "DELETE"
+}
+export declare enum PrimitiveType {
+    string = "string",
+    number = "number",
+    boolean = "boolean"
+}
+export type primitive = string | number | boolean | Date;
+export type DocumentFieldValue = any;
+export type DocumentData = {
+    [field: string]: DocumentFieldValue;
+};
+export interface HttpError {
+    message: string;
+    context?: string;
+}
+export interface HttpResult {
+    errors?: HttpError[];
+    statusCode: number;
+    payload?: object | object[];
+}
+export declare const castHttpError: (error: Partial<HttpError>) => HttpError | undefined;

package/dist/types/handler/HttpHandler.d.ts

@@ -0,0 +1,15 @@
+import express from "express";
+import { StoreBaseDoc, StorePersistDoc } from "../store/types.store.js";
+import { HttpsFunction } from "firebase-functions/v2/https";
+import { IHttpHandlerItem } from "./IHttpHandlerItem.js";
+export declare class HttpHandler {
+    readonly name: string;
+    readonly exp: express.Express;
+    readonly corsAllowList: string[];
+    protected readonly items: IHttpHandlerItem<StoreBaseDoc, StorePersistDoc>[];
+    constructor(name: string);
+    add<DOC extends StoreBaseDoc, STORE_DOC extends StorePersistDoc>(...items: IHttpHandlerItem<DOC, STORE_DOC>[]): HttpHandler;
+    protected baseSetup(): void;
+    setup(): HttpsFunction;
+    protected createFunction(): HttpsFunction;
+}

package/dist/types/handler/IHttpHandlerItem.d.ts

@@ -0,0 +1,23 @@
+import express from "express";
+import { StoreBaseDoc, StorePersistDoc } from "../store/types.store.js";
+import { IApi } from "../api/IApi.js";
+import { HttpsFunction } from "firebase-functions/v2/https";
+import { HttpError } from "../common/types.common.js";
+import { StatusCodes } from "@mxpicture/http-status-codes";
+import { $ZodErrorTree } from "zod/v4/core";
+export declare abstract class IHttpHandlerItem<DOC extends StoreBaseDoc, STORE_DOC extends StorePersistDoc> {
+    readonly name: string;
+    readonly api: IApi<DOC, STORE_DOC>;
+    readonly corsAllowList: string[];
+    constructor(name: string, api: IApi<DOC, STORE_DOC>);
+    setup(exp: express.Express): void;
+    protected httpSuccess(res: express.Response, payload: object | object[], statusCode?: StatusCodes): express.Response;
+    protected httpError(res: express.Response, errors: HttpError[], statusCode?: StatusCodes): express.Response;
+    protected httpErrorUnnown(res: express.Response, error: unknown, statusCode?: StatusCodes): express.Response;
+    protected extractZodError<T>(tree: Partial<$ZodErrorTree<T, string>>, ...contexts: (string | number)[]): HttpError[];
+    protected contextPath(...parts: (string | number | undefined)[]): string;
+    protected createFunction(exp: express.Express): HttpsFunction;
+    protected extractBody(req: express.Request): Promise<Partial<DOC> | Partial<DOC>[]>;
+    protected extractBodyItem(req: express.Request): Promise<Partial<DOC>>;
+    protected extractBodyItems(req: express.Request): Promise<Partial<DOC>[]>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./lib";
+import * as _all from "./lib";
+export default _all;

package/dist/types/lib.d.ts

@@ -0,0 +1,11 @@
+export * from "./FunctionHandlers";
+export * from "./handler/IHttpHandlerItem";
+export * from "./handler/HttpHandler";
+export * from "./common/firebase";
+export * from "./common/http";
+export * from "./common/types.common";
+export * from "./api/IApi";
+export * from "./store/IStore";
+export * from "./store/types.store";
+export { ZodRawShape, ZodSafeParseResult } from "zod";
+export { HttpsFunction } from "firebase-functions/v2/https";

package/dist/types/package.d.ts

@@ -0,0 +1 @@
+export * from "./lib";

package/dist/types/store/IStore.d.ts

@@ -0,0 +1,25 @@
+import { CollectionReference, DocumentReference, DocumentSnapshot, FirestoreDataConverter } from "firebase-admin/firestore";
+import { StoreBaseDoc, StorePersistDoc } from "./types.store.js";
+import { DocumentData } from "../common/types.common.js";
+export declare const convertDocObject: <T extends StoreBaseDoc>(doc: DocumentData | DocumentSnapshot) => T;
+export declare abstract class IStore<DOC extends StoreBaseDoc, STORE_DOC extends StorePersistDoc> {
+    readonly collectionName: string;
+    protected _db?: CollectionReference<STORE_DOC>;
+    protected constructor(collectionName: string);
+    protected abstract createConverter(): FirestoreDataConverter<STORE_DOC>;
+    db(): CollectionReference<STORE_DOC>;
+    query(p?: {
+        parentId?: string;
+    }): Promise<STORE_DOC[]>;
+    count(p?: {
+        parentId?: string;
+    }): Promise<number>;
+    ref(id: string): DocumentReference;
+    get(id: string): Promise<STORE_DOC>;
+    exists(id: string): Promise<boolean>;
+    create(doc: DOC): Promise<STORE_DOC>;
+    update(id: string, doc: Partial<STORE_DOC>): Promise<STORE_DOC>;
+    delete(...ids: string[]): Promise<void>;
+    deleteByParent(parentId: string): Promise<void>;
+    refByParent(parentId: string): FirebaseFirestore.Query<STORE_DOC, FirebaseFirestore.DocumentData>;
+}

package/dist/types/store/types.store.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const storeBaseSchemaShape: {
+    id: z.ZodOptional<z.ZodString>;
+    createTime: z.ZodOptional<z.ZodDate>;
+    updateTime: z.ZodOptional<z.ZodDate>;
+};
+export declare const storePersistSchemaShape: {
+    id: z.ZodString;
+    createTime: z.ZodOptional<z.ZodDate>;
+    updateTime: z.ZodOptional<z.ZodDate>;
+};
+export declare const storeBaseSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    createTime: z.ZodOptional<z.ZodDate>;
+    updateTime: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export type StoreBaseDoc = z.infer<typeof storeBaseSchema>;
+export declare const storePersistSchema: z.ZodObject<{
+    id: z.ZodString;
+    createTime: z.ZodOptional<z.ZodDate>;
+    updateTime: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export type StorePersistDoc = z.infer<typeof storePersistSchema>;