@open-xamu-co/firebase-nuxt 1.0.0 → 1.1.0

package/dist/runtime/server/utils/firestore.d.ts

@@ -0,0 +1,27 @@
+import { type H3Event, type EventHandlerRequest } from "h3";
+import { type DocumentData, DocumentSnapshot, Query } from "firebase-admin/firestore";
+import { QuerySnapshot } from "@google-cloud/firestore";
+import type { iPage, iPageEdge } from "@open-xamu-co/ui-common-types";
+import type { PseudoNode, FirebaseDocument, iSnapshotConfig } from "../../client/types/index.js";
+/**
+ * Logging for debugging purposes on server
+ */
+export declare function debugFirebaseServer<T extends EventHandlerRequest>(event: H3Event<T>, mss: string, ...args: any[]): void;
+/**
+ * This one is used on api endpoints
+ */
+export declare function resolveServerDocumentRefs<T extends PseudoNode, R extends FirebaseDocument = FirebaseDocument>(event: H3Event, snapshot?: DocumentSnapshot<T>, collection?: string, withAuth?: boolean): Promise<R | undefined>;
+/**
+ * Resolve general refs
+ */
+export declare function resolveServerRefs<T extends PseudoNode, R extends FirebaseDocument = FirebaseDocument>(snapshot: DocumentSnapshot<T, R>, config?: iSnapshotConfig, withAuth?: boolean): Promise<R | undefined>;
+export declare function mapEdges<T extends Record<string, any>>(collectionSnapshot: QuerySnapshot<T>, encoder: (v: any) => string, snapshotConfig: iSnapshotConfig): Promise<iPageEdge<FirebaseDocument, string>[]>;
+export declare function getOrderedQuery<T extends EventHandlerRequest>(event: H3Event<T>, query: Query): Query;
+/**
+ * Get the edges from a given query
+ */
+export declare function getQueryAsEdges<T extends EventHandlerRequest>(event: H3Event<T>, query: Query, callback?: (v: QuerySnapshot<DocumentData>) => void | Promise<void>): Promise<iPageEdge<DocumentData, string>[]>;
+/**
+ * Cursor pagination from a given query
+ */
+export declare function getEdgesPage<T extends EventHandlerRequest>(event: H3Event<T>, query: Query): Promise<iPage<DocumentData, string>>;

package/dist/runtime/server/utils/firestore.js

@@ -0,0 +1,137 @@
+import { getRequestURL, createError, getQuery } from "h3";
+import { useEvent } from "nitropack/runtime";
+import { getBoolean, isNumberOrString } from "../utils/guards.js";
+import { makeResolveRefs } from "../../client/utils/resolver.js";
+import { apiLogger, getServerFirebase } from "./firebase.js";
+import { debugFirebase } from "../utils/environment.js";
+import { sudo } from "#internal/firebase-nuxt";
+const decodeCursor = (cursor) => Buffer.from(cursor, "base64").toString("utf8");
+const encodeCursor = (ref) => {
+  return Buffer.from(ref.path).toString("base64");
+};
+export function debugFirebaseServer(event, mss, ...args) {
+  if (debugFirebase && import.meta.server) {
+    const url = getRequestURL(event);
+    console.group("\x1B[34m%s\x1B[0m", url);
+    console.log(`${mss},`, ...args);
+    console.groupEnd();
+  }
+}
+export function resolveServerDocumentRefs(event, snapshot, collection = "documents", withAuth) {
+  if (!snapshot?.exists) {
+    let statusMessage = `No "${collection}" matched`;
+    if (snapshot?.ref.path) statusMessage = `${statusMessage} for ${snapshot.ref.path}`;
+    throw createError({ statusCode: 404, statusMessage });
+  }
+  const params = getQuery(event);
+  const level = Array.isArray(params.level) || !params.level ? 0 : Number(params.level);
+  const omit = Array.isArray(params.omit) ? params.omit : [params.omit];
+  return resolveServerRefs(snapshot, { level, omit }, withAuth);
+}
+export async function resolveServerRefs(snapshot, config = {}, withAuth) {
+  const event = useEvent();
+  const resolveRefs = makeResolveRefs((ref) => ref.get?.());
+  try {
+    if (withAuth === void 0) withAuth = sudo(event.context);
+  } catch (err) {
+    const payload = [`resolveServerRefs:${snapshot.ref.path}`, err];
+    config.logger ? config.logger(...payload) : apiLogger(event, ...payload);
+  }
+  return resolveRefs(snapshot, config, withAuth);
+}
+const edge = (e) => !!e;
+export async function mapEdges(collectionSnapshot, encoder, snapshotConfig) {
+  const edges = await Promise.all(
+    collectionSnapshot.docs.map(async (document) => {
+      const node = await resolveServerRefs(document, snapshotConfig);
+      if (node) return { cursor: encoder(document.ref), node };
+    })
+  );
+  return edges.filter(edge);
+}
+export function getOrderedQuery(event, query) {
+  const params = getQuery(event);
+  const orderByParam = Array.isArray(params.orderBy?.[0]) ? params.orderBy[0] : [];
+  const orderByValues = [orderByParam[0] ?? "createdAt", orderByParam[1] ?? "desc"];
+  return query.orderBy(...orderByValues);
+}
+export async function getQueryAsEdges(event, query, callback) {
+  const params = getQuery(event);
+  const page = getBoolean(params.page);
+  const level = Array.isArray(params.level) || !params.level ? 0 : Number(params.level);
+  const omit = Array.isArray(params.omit) ? params.omit : [params.omit];
+  debugFirebaseServer(event, "getQueryAsEdges", params);
+  if (!page) {
+    const first = Math.min(Number(params.first) || 10, 100);
+    query = query.limit(first);
+  }
+  const snapshot = await query.get();
+  Promise.resolve(callback?.(snapshot)).catch((err) => {
+    apiLogger(event, "getQueryAsEdges:callback", err);
+  });
+  return mapEdges(snapshot, encodeCursor, { level, omit });
+}
+export async function getEdgesPage(event, query) {
+  const { firebaseFirestore } = getServerFirebase(`api:getEdgesPage:${event.path}`);
+  const params = getQuery(event);
+  const at = isNumberOrString(params.at) ? params.at : void 0;
+  let first = Math.min(Number(params.first) || 10, 100);
+  const page = {
+    edges: [],
+    pageInfo: {
+      hasNextPage: false,
+      hasPreviousPage: false,
+      pageNumber: 0,
+      path: event.path
+    },
+    totalCount: 0
+  };
+  const aggregatorRef = query.count();
+  let cursorRef = query;
+  let startAtCursor;
+  if (typeof at === "string") {
+    const [aggregatorSnapshot, snapshot] = await Promise.all([
+      aggregatorRef.get(),
+      firebaseFirestore.doc(decodeCursor(at)).get()
+    ]);
+    const count = aggregatorSnapshot.data().count;
+    first = Math.min(first, count);
+    page.totalCount = count;
+    if (snapshot.exists) {
+      startAtCursor = snapshot;
+      cursorRef = cursorRef.startAt(snapshot);
+    }
+  } else {
+    if (at !== void 0) cursorRef = cursorRef.startAt(at);
+    const { count } = (await aggregatorRef.get()).data();
+    first = Math.min(first, count);
+    page.totalCount = count;
+  }
+  if (!page.totalCount) return page;
+  const paginatedRef = cursorRef.limit(first + 1);
+  if (startAtCursor) {
+    const previousPaginatedRef = query.endBefore(startAtCursor);
+    const previousAggregatorRef = previousPaginatedRef.count();
+    const [edges, previousCountRef, previousSnapshot] = await Promise.all([
+      getQueryAsEdges(event, paginatedRef),
+      previousAggregatorRef.get(),
+      previousPaginatedRef.limitToLast(first).get()
+    ]);
+    const { count } = previousCountRef.data();
+    page.edges = edges;
+    page.pageInfo.pageNumber = Math.floor(count / first) + 1;
+    if (!previousSnapshot.empty) {
+      page.pageInfo.hasPreviousPage = true;
+      page.pageInfo.previousCursor = encodeCursor(previousSnapshot.docs[0].ref);
+    }
+  } else {
+    page.edges = await getQueryAsEdges(event, paginatedRef);
+    page.pageInfo.pageNumber = 1;
+  }
+  if (page.edges.length > first) {
+    const nextEdge = page.edges.pop();
+    page.pageInfo.hasNextPage = !!nextEdge;
+    page.pageInfo.nextCursor = nextEdge?.cursor;
+  }
+  return page;
+}

package/dist/runtime/server/utils/guards.d.ts

@@ -0,0 +1,15 @@
+export declare function isNumberOrString(v: unknown): v is number | string;
+export declare function isFileArray<T>(values?: File[] | T[]): values is File[];
+export declare function getBoolean(value?: unknown, prefer?: boolean): boolean;
+type tPromiseExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void;
+/**
+ * Fails promise if it takes too long (30s by default)
+ * Any error must be capture within the executor and rejected
+ *
+ * @see https://ourcodeworld.com/articles/read/1544/how-to-implement-a-timeout-for-javascript-promises
+ */
+export declare function TimedPromise<T>(executor: tPromiseExecutor<T>, { fallback, timeout }?: {
+    fallback?: T;
+    timeout?: number;
+}): Promise<T>;
+export {};

package/dist/runtime/server/utils/guards.js

@@ -0,0 +1,23 @@
+export function isNumberOrString(v) {
+  return ["number", "string"].includes(typeof v);
+}
+export function isFileArray(values) {
+  return !values?.every((v) => Array.isArray(v));
+}
+export function getBoolean(value, prefer) {
+  if (value && typeof value === "string") {
+    return value.toUpperCase() === "TRUE";
+  }
+  return !!prefer;
+}
+export function TimedPromise(executor, { fallback, timeout = 1e3 * 30 } = {}) {
+  return Promise.race([
+    new Promise(executor),
+    new Promise((resolve, reject) => {
+      setTimeout(() => {
+        if (fallback) return resolve(fallback);
+        reject("Timed out");
+      }, timeout);
+    })
+  ]);
+}

package/dist/runtime/server/utils/instance.d.ts

@@ -0,0 +1,21 @@
+import type { Instance } from "../../client/types/index.js";
+/**
+ * Get the current instance if it exists
+ *
+ * Forwarded host is prefered
+ *
+ * @see https://stackoverflow.com/a/51200572/3304008
+ *
+ * @cache 1 hour
+ */
+export declare const getInstance: (_: any, fullHost: string) => Promise<Instance & {
+    millis: string;
+    url: string;
+    id: string;
+}>;
+/**
+ * Get the root instance
+ *
+ * @cache 1 hour
+ */
+export declare const getRootInstance: (_: any) => Promise<Instance | undefined>;

package/dist/runtime/server/utils/instance.js

@@ -0,0 +1,68 @@
+import { createError } from "h3";
+import { defineCachedFunction } from "nitropack/runtime";
+import { production, forcedInstanceId } from "../utils/environment.js";
+import { debugFirebaseServer, resolveServerDocumentRefs } from "./firestore.js";
+import { getServerFirebase } from "./firebase.js";
+export const getInstance = defineCachedFunction(
+  async (event, fullHost) => {
+    const { firebaseFirestore } = getServerFirebase("api:getInstance");
+    const instancesRef = firebaseFirestore.collection("instances");
+    let snapshot;
+    const [host] = fullHost.split(":");
+    debugFirebaseServer(event, "middleware:getInstance", host);
+    if (forcedInstanceId) {
+      snapshot = await instancesRef.doc(forcedInstanceId).get();
+    } else {
+      const instancesQuery = await instancesRef.where("config.domains", "array-contains", host).limit(1).get();
+      snapshot = instancesQuery.docs[0];
+      if (!snapshot?.exists) {
+        throw createError({
+          statusCode: 404,
+          statusMessage: `No instance found for ${host}`,
+          cause: "NOT_FOUND"
+        });
+      }
+    }
+    const millis = snapshot.data()?.createdAt?.toMillis();
+    const instance = await resolveServerDocumentRefs(event, snapshot, "instances", false) || {};
+    if (!instance.id || !millis) {
+      throw createError({
+        statusCode: 502,
+        statusMessage: `Invalid app instance for ${host}`,
+        cause: "MALFORMED_DATA"
+      });
+    }
+    let url = `https://${host}`;
+    if (!production) url = `http://${fullHost}`;
+    return {
+      ...instance,
+      id: instance.id,
+      url,
+      millis: String(millis)
+    };
+  },
+  {
+    name: "getInstance",
+    maxAge: 60 * 60,
+    // 1 hour
+    getKey: (_, fullHost) => {
+      const [host] = fullHost.split(":");
+      return host;
+    }
+  }
+);
+export const getRootInstance = defineCachedFunction(
+  async (event) => {
+    const { firebaseFirestore } = getServerFirebase("api:getRootInstance");
+    const instancesRef = firebaseFirestore.collection("instances");
+    debugFirebaseServer(event, "middleware:getRootInstance");
+    const snapshot = await instancesRef.doc("root").get();
+    return resolveServerDocumentRefs(event, snapshot, "instances", false) || {};
+  },
+  {
+    name: "getRootInstance",
+    maxAge: 60 * 60 * 24,
+    // 1 day
+    getKey: (_) => "root"
+  }
+);

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-xamu-co/firebase-nuxt",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Nuxt 3 module for the xamu project",
   "author": "@xamu-co",
   "type": "module",
@@ -50,33 +50,33 @@
     },
     "./client": {
       "types": "./dist/runtime/client/types/index.d.ts",
-      "import": "./dist/runtime/client/types/index.d.ts",
-      "default": "./dist/runtime/client/types/index.d.ts"
+      "import": "./dist/runtime/client/types/index.js",
+      "default": "./dist/runtime/client/types/index.js"
     },
     "./client/*": {
-      "types": "./dist/runtime/client/*.d.ts",
-      "import": "./dist/runtime/client/*.ts",
-      "default": "./dist/runtime/client/*.ts"
+      "types": "./dist/runtime/client/utils/*.d.ts",
+      "import": "./dist/runtime/client/utils/*.js",
+      "default": "./dist/runtime/client/utils/*.js"
     },
     "./functions": {
       "types": "./dist/runtime/functions/types/index.d.ts",
-      "import": "./dist/runtime/functions/types/index.d.ts",
-      "default": "./dist/runtime/functions/types/index.d.ts"
+      "import": "./dist/runtime/functions/types/index.js",
+      "default": "./dist/runtime/functions/types/index.js"
     },
     "./functions/*": {
-      "types": "./dist/runtime/functions/*.d.ts",
-      "import": "./dist/runtime/functions/*.ts",
-      "default": "./dist/runtime/functions/*.ts"
+      "types": "./dist/runtime/functions/utils/*.d.ts",
+      "import": "./dist/runtime/functions/utils/*.js",
+      "default": "./dist/runtime/functions/utils/*.js"
     },
     "./server": {
       "types": "./dist/runtime/server/types/index.d.ts",
-      "import": "./dist/runtime/server/types/index.d.ts",
-      "default": "./dist/runtime/server/types/index.d.ts"
+      "import": "./dist/runtime/server/types/index.js",
+      "default": "./dist/runtime/server/types/index.js"
     },
     "./server/*": {
-      "types": "./dist/runtime/server/*.d.ts",
-      "import": "./dist/runtime/server/*.ts",
-      "default": "./dist/runtime/server/*.ts"
+      "types": "./dist/runtime/server/utils/*.d.ts",
+      "import": "./dist/runtime/server/utils/*.js",
+      "default": "./dist/runtime/server/utils/*.js"
     }
   },
   "files": [
@@ -86,7 +86,7 @@
     "@nuxt/kit": "^3.20.2",
     "@open-xamu-co/ui-common-enums": "^4.0.0-next.1",
     "@open-xamu-co/ui-common-helpers": "^4.0.0-next.2",
-    "@open-xamu-co/ui-nuxt": "^4.0.0-next.4",
+    "@open-xamu-co/ui-nuxt": "^4.0.0-next.6",
     "@pinia/nuxt": "^0.11.0",
     "firebase": "^11.0.2",
     "firebase-admin": "^13.6.0",