@open-xamu-co/firebase-nuxt 2.0.0-next.1 → 2.0.0-next.2

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 Firebase nuxt
 
+# [2.0.0-next.2](https://github.com/xamu-co/firebase-nuxt/compare/v2.0.0-next.1...v2.0.0-next.2) (2026-01-15)
+
+
+### Bug Fixes
+
+* prevent no content on head responses ([a16a768](https://github.com/xamu-co/firebase-nuxt/commit/a16a7682d3fb322bafda64177f5d57541069beac))
+
+
+### Features
+
+* accept head & options request ([2822f2f](https://github.com/xamu-co/firebase-nuxt/commit/2822f2ffeb27cc5b6034cb4fe131ae20ae0bde99))
+
+
+### BREAKING CHANGES
+
+* less args at resolveServerDocumentRefs
+
 # [2.0.0-next.1](https://github.com/xamu-co/firebase-nuxt/compare/v1.2.0-next.2...v2.0.0-next.1) (2026-01-13)
 
 

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^3.0.0"
   },
-  "version": "1.2.0-next.2",
+  "version": "2.0.0-next.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -84,37 +84,40 @@ const module$1 = defineNuxtModule({
       middleware: true,
       handler: resolve(runtimePath, "server/middleware/1.context")
     });
-    if (moduleOptions.media) {
-      addServerHandler({
-        method: "get",
-        route: "/api/media/**:path",
-        handler: resolve(runtimePath, "server/api/media.get")
-      });
-    }
-    if (moduleOptions.readCollection) {
-      addServerHandler({
-        method: "get",
-        route: "/api/all/:collectionId",
-        handler: resolve(runtimePath, "server/api/all-collection.get")
-      });
-      addServerHandler({
-        method: "get",
-        route: "/api/all/:collectionId/:documentId",
-        handler: resolve(runtimePath, "server/api/all-collection-document.get")
-      });
-    }
-    if (moduleOptions.readInstanceCollection) {
-      addServerHandler({
-        method: "get",
-        route: "/api/instance/all/:collectionId",
-        handler: resolve(runtimePath, "server/api/all-collection.get")
-      });
-      addServerHandler({
-        method: "get",
-        route: "/api/instance/all/:collectionId/:documentId",
-        handler: resolve(runtimePath, "server/api/all-collection-document.get")
-      });
-    }
+    const methods = ["get", "head", "options"];
+    methods.forEach((method) => {
+      if (moduleOptions.media) {
+        addServerHandler({
+          method,
+          route: "/api/media/**:path",
+          handler: resolve(runtimePath, "server/api/media")
+        });
+      }
+      if (moduleOptions.readCollection) {
+        addServerHandler({
+          method,
+          route: "/api/all/:collectionId",
+          handler: resolve(runtimePath, "server/api/all-collection")
+        });
+        addServerHandler({
+          method,
+          route: "/api/all/:collectionId/:documentId",
+          handler: resolve(runtimePath, "server/api/all-collection-document")
+        });
+      }
+      if (moduleOptions.readInstanceCollection) {
+        addServerHandler({
+          method,
+          route: "/api/instance/all/:collectionId",
+          handler: resolve(runtimePath, "server/api/all-collection")
+        });
+        addServerHandler({
+          method,
+          route: "/api/instance/all/:collectionId/:documentId",
+          handler: resolve(runtimePath, "server/api/all-collection-document")
+        });
+      }
+    });
   },
   moduleDependencies() {
     const { resolve } = createResolver(import.meta.url);

package/dist/runtime/client/types/entities/logs.d.ts

@@ -1,4 +1,5 @@
-import type { LogData } from "../../../functions/types/index.js";
+import type { DocumentReference } from "firebase/firestore";
+import type { LogData, OffenderData } from "../../../functions/types/index.js";
 import type { FromData } from "./base.js";
 import type { GetSharedRef } from "./user.js";
 /** @output Log */
@@ -7,3 +8,11 @@ export interface Log extends FromData<LogData> {
 /** @input Omit automation */
 export interface LogRef extends GetSharedRef<Log> {
 }
+/** @output Offender */
+export interface Offender extends FromData<OffenderData> {
+    lastLog?: Log;
+}
+/** @input Omit automation */
+export interface OffenderRef extends GetSharedRef<Offender> {
+    lastLogRef?: DocumentReference<LogData>;
+}

package/dist/runtime/client/types/entities/user.d.ts

@@ -9,7 +9,7 @@ import type { Instance, SharedDocument } from "./instance.js";
  * Removed properties are not required or are part of automation
  */
 export type GetSharedRef<T extends SharedDocument, O extends keyof T = never> = {
-    [K in keyof FromData<Omit<T, "id" | O>> as K extends `${string}At` ? never : K]: FromData<Omit<T, "id" | O>>[K];
+    [K in keyof FromData<Omit<T, O>> as K extends `${string}At` ? never : K]: FromData<Omit<T, O>>[K];
 } & {
     createdByRef?: DocumentReference | FieldValue;
     updatedByRef?: DocumentReference | FieldValue;

package/dist/runtime/composables/firestore/write.d.ts

@@ -1,11 +1,11 @@
 import { DocumentReference } from "firebase/firestore";
 import type { iNodeFnResponseStream } from "@open-xamu-co/ui-common-types";
-import type { GetRef, SharedDocument, FirebaseDocument, iSnapshotConfig } from "../../client/types/index.js";
+import type { GetRef, SharedDocument, FirebaseDocument, iSnapshotConfig, FromData } from "../../client/types/index.js";
 interface iUseDocumentOptions extends iSnapshotConfig {
     omitLoggings?: boolean;
 }
 /** Creates document with the given values */
-export declare function useDocumentCreate<Vgr extends GetRef<V>, V extends FirebaseDocument = FirebaseDocument>(collectionPath: string, partialRef: Vgr, createdCallback?: (ref: DocumentReference<Vgr, V>) => Promise<void> | void, { omitLoggings, ...config }?: iUseDocumentOptions): Promise<iNodeFnResponseStream<V>>;
+export declare function useDocumentCreate<Vgr extends GetRef<SharedDocument>, V extends FromData<Vgr> = FromData<Vgr>>(collectionPath: string, partialRef: Vgr, createdCallback?: (ref: DocumentReference<Vgr, V>) => Promise<void> | void, { omitLoggings, ...config }?: iUseDocumentOptions): Promise<iNodeFnResponseStream<V>>;
 /**
  * Updates a given document in Firestore.
  *
@@ -13,9 +13,9 @@ export declare function useDocumentCreate<Vgr extends GetRef<V>, V extends Fireb
  * @param partialRef - The partial data to update the document with.
  * @returns A boolean promise.
  */
-export declare function useDocumentUpdate<Vgr extends GetRef<V>, V extends FirebaseDocument = FirebaseDocument>(node: SharedDocument, middleRef?: Partial<Vgr>, { omitLoggings, ...config }?: iUseDocumentOptions): Promise<iNodeFnResponseStream<V>>;
+export declare function useDocumentUpdate<Vgr extends GetRef<SharedDocument>, V extends FromData<Vgr> = FromData<Vgr>>(node: SharedDocument, middleRef?: Partial<Vgr>, { omitLoggings, ...config }?: iUseDocumentOptions): Promise<iNodeFnResponseStream<V>>;
 /** Clones given document */
-export declare function useDocumentClone<Vgr extends GetRef<V>, V extends FirebaseDocument = FirebaseDocument>(node: SharedDocument, middleRef?: Partial<Vgr>, { omitLoggings, ...config }?: iUseDocumentOptions): Promise<iNodeFnResponseStream<V>>;
+export declare function useDocumentClone<Vgr extends GetRef<SharedDocument>, V extends FromData<Vgr> = FromData<Vgr>>(node: SharedDocument, middleRef?: Partial<Vgr>, { omitLoggings, ...config }?: iUseDocumentOptions): Promise<iNodeFnResponseStream<V>>;
 /** Deletes given document */
 export declare function useDocumentDelete<T extends FirebaseDocument = FirebaseDocument>(node: SharedDocument, { omitLoggings }?: iUseDocumentOptions): Promise<iNodeFnResponseStream<T>>;
 export {};

package/dist/runtime/functions/types/entities/instance.d.ts

@@ -30,6 +30,12 @@ export interface RootData extends InstanceData {
     /** @example "Xamu" */
     poweredBy?: string;
 }
+export interface InstanceDataConfig extends FirebaseData {
+    /**
+     * When tenants are enabled, domains are required
+     */
+    domains?: string[];
+}
 /**
  * App instance
  *
@@ -46,13 +52,7 @@ export interface InstanceData extends SharedData {
      * @automated
      */
     url?: string;
-    config?: {
-        [key: string]: any;
-        /**
-         * When tenants are enabled, domains are required
-         */
-        domains?: string[];
-    };
+    config?: InstanceDataConfig;
 }
 /**
  * Firebase log

package/dist/runtime/functions/types/entities/logs.d.ts

@@ -1,3 +1,4 @@
+import type { DocumentReference } from "firebase-admin/firestore";
 import type { FirebaseData } from "./base.js";
 /** General log entity */
 export interface LogData extends FirebaseData {
@@ -13,3 +14,28 @@ export interface LogData extends FirebaseData {
      */
     internal?: boolean;
 }
+/**
+ * Offender entity
+ *
+ * Keep track of abbussive requests
+ */
+export interface OffenderData extends FirebaseData {
+    /** IP address */
+    ip?: string;
+    /** ISO country codes */
+    countries?: string[];
+    /** User agents */
+    userAgents?: string[];
+    /** Preferred languages */
+    languages?: string[];
+    /**
+     * Number of hits
+     * @automated
+     */
+    hits?: number;
+    /**
+     * Log reference
+     * @automated
+     */
+    lastLogRef?: DocumentReference<LogData>;
+}

package/dist/runtime/functions/utils/logger.d.ts

@@ -1,3 +1,7 @@
 import { DocumentReference, type Firestore } from "firebase-admin/firestore";
 import type { tLogger } from "@open-xamu-co/ui-common-types";
 export declare function makeFunctionsLogger(at: DocumentReference | Firestore, authorRef?: DocumentReference, metadata?: Record<string, any>): tLogger;
+/**
+ * Log offending requests sources
+ */
+export declare function offenderLogger(at: DocumentReference | Firestore, lastLogRef: DocumentReference, metadata?: any): void;

package/dist/runtime/functions/utils/logger.js

@@ -1,4 +1,8 @@
-import { DocumentReference } from "firebase-admin/firestore";
+import {
+  DocumentReference,
+  FieldValue
+} from "firebase-admin/firestore";
+import acceptLanguageParser from "accept-language-parser";
 import { getLog } from "./logs.js";
 export function makeFunctionsLogger(at, authorRef, metadata = {}) {
   return function(...args) {
@@ -15,3 +19,22 @@ export function makeFunctionsLogger(at, authorRef, metadata = {}) {
     }
   };
 }
+export function offenderLogger(at, lastLogRef, metadata) {
+  if (!metadata || typeof metadata !== "object") return;
+  const headers = metadata.headers || {};
+  const ip = headers["cf-connecting-ip"] || headers["x-fah-client-ip"] || headers["ip"];
+  const userAgent = headers["from"] || headers["user-agent"];
+  const country = headers["cf-ipcountry"];
+  const [preferredLanguage] = acceptLanguageParser.parse(headers["accept-language"]);
+  if (!ip) return;
+  const offendersRef = at.collection("offenders");
+  const offenderDoc = offendersRef.doc(ip);
+  const offenderData = { ip, hits: FieldValue.increment(1), lastLogRef };
+  if (country) offenderData.countries = FieldValue.arrayUnion(country);
+  if (userAgent) offenderData.userAgents = FieldValue.arrayUnion(userAgent);
+  if (preferredLanguage) {
+    const { code, region } = preferredLanguage;
+    offenderData.languages = FieldValue.arrayUnion(`${code}-${region}`);
+  }
+  offenderDoc.set(offenderData, { merge: true });
+}

package/dist/runtime/server/api/{all-collection-document.get.d.ts → all-collection-document.d.ts}

@@ -3,5 +3,5 @@
  *
  * @auth guest
  */
-declare const _default: import("../types/index.js").CachedEventHandler<import("h3").EventHandlerRequest, Promise<void | FirebaseFirestore.DocumentData>>;
+declare const _default: import("../types/index.js").CachedEventHandler<import("h3").EventHandlerRequest, Promise<void | FirebaseFirestore.DocumentData | "Ok">>;
 export default _default;

package/dist/runtime/server/api/all-collection-document.js

@@ -0,0 +1,75 @@
+import {
+  createError,
+  getRouterParam,
+  isError,
+  sendNoContent,
+  setResponseHeaders,
+  setResponseStatus
+} from "h3";
+import { defineConditionallyCachedEventHandler } from "../utils/cache.js";
+import { debugFirebaseServer, resolveServerDocumentRefs } from "../utils/firestore.js";
+import { apiLogger, getServerFirebase } from "../utils/firebase.js";
+import { readCollection, readInstanceCollection } from "#internal/firebase-nuxt";
+export default defineConditionallyCachedEventHandler(async (event) => {
+  const { firebaseFirestore } = getServerFirebase("api:all:[collectionId]:[documentId]");
+  const { currentInstanceRef } = event.context;
+  const Allow = "GET,HEAD";
+  try {
+    setResponseHeaders(event, {
+      Allow,
+      "Access-Control-Allow-Methods": Allow,
+      "Content-Type": "application/json"
+    });
+    if (!["GET", "HEAD", "OPTIONS"].includes(event.method?.toUpperCase())) {
+      throw createError({ statusCode: 405, statusMessage: "Unsupported method" });
+    } else if (event.method?.toUpperCase() === "OPTIONS") {
+      return sendNoContent(event);
+    }
+    const collectionId = getRouterParam(event, "collectionId");
+    const documentId = getRouterParam(event, "documentId");
+    debugFirebaseServer(event, "api:all:[collectionId]:[documentId]", collectionId, documentId);
+    if (!collectionId || !documentId) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: `collectionId & documentId are required`
+      });
+    }
+    let collectionRef = firebaseFirestore.collection(collectionId);
+    if (event.path.startsWith("/api/instance/all")) {
+      if (!currentInstanceRef) {
+        throw createError({ statusCode: 401, statusMessage: "Missing instance" });
+      } else if (!readInstanceCollection(collectionId, event.context)) {
+        throw createError({
+          statusCode: 401,
+          statusMessage: `Can't get "instance/${collectionId}" document`
+        });
+      }
+      collectionRef = currentInstanceRef.collection(collectionId);
+    } else if (!readCollection(collectionId, event.context)) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: `Can't get "${collectionId}" document`
+      });
+    }
+    const documentsRef = collectionRef.doc(documentId);
+    const documentSnapshot = await documentsRef.get();
+    if (!documentSnapshot?.exists) {
+      let statusMessage = `No "${collectionId}" document matched`;
+      if (documentSnapshot?.ref.path) {
+        statusMessage = `${statusMessage} for ${documentSnapshot.ref.path}`;
+      }
+      throw createError({ statusCode: 404, statusMessage });
+    }
+    if (event.method?.toUpperCase() === "HEAD") {
+      setResponseStatus(event, 200);
+      return "Ok";
+    }
+    return resolveServerDocumentRefs(event, documentSnapshot);
+  } catch (err) {
+    if (isError(err)) {
+      apiLogger(event, "api:all:[collectionId]:[documentId]", err.message, err);
+      return setResponseStatus(event, err.statusCode || 500, err.statusMessage);
+    }
+    throw err;
+  }
+});

package/dist/runtime/server/api/{all-collection.get.d.ts → all-collection.d.ts}

@@ -4,5 +4,5 @@
  * @auth guest
  * @order createdAt
  */
-declare const _default: import("../types/index.js").CachedEventHandler<import("h3").EventHandlerRequest, Promise<void | import("@open-xamu-co/ui-common-types").iPageEdge<FirebaseFirestore.DocumentData, string>[] | import("@open-xamu-co/ui-common-types").iPage<FirebaseFirestore.DocumentData, string>>>;
+declare const _default: import("../types/index.js").CachedEventHandler<import("h3").EventHandlerRequest, Promise<void | import("@open-xamu-co/ui-common-types").iPageEdge<FirebaseFirestore.DocumentData, string>[] | import("@open-xamu-co/ui-common-types").iPage<FirebaseFirestore.DocumentData, string> | "Ok">>;
 export default _default;

package/dist/runtime/server/api/all-collection.js

@@ -0,0 +1,85 @@
+import { FieldPath } from "firebase-admin/firestore";
+import {
+  createError,
+  getQuery,
+  getRouterParam,
+  isError,
+  sendNoContent,
+  setResponseHeaders,
+  setResponseStatus
+} from "h3";
+import { defineConditionallyCachedEventHandler } from "../utils/cache.js";
+import { getBoolean } from "../utils/guards.js";
+import { getDocumentId } from "../../client/utils/resolver.js";
+import {
+  debugFirebaseServer,
+  getEdgesPage,
+  getOrderedQuery,
+  getQueryAsEdges
+} from "../utils/firestore.js";
+import { apiLogger, getServerFirebase } from "../utils/firebase.js";
+import { readCollection, readInstanceCollection } from "#internal/firebase-nuxt";
+export default defineConditionallyCachedEventHandler(async (event) => {
+  const fieldDocument = FieldPath.documentId();
+  const { firebaseFirestore } = getServerFirebase("api:all:[collectionId]");
+  const { currentInstanceRef } = event.context;
+  const Allow = "GET,HEAD";
+  try {
+    setResponseHeaders(event, {
+      Allow,
+      "Access-Control-Allow-Methods": Allow,
+      "Content-Type": "application/json"
+    });
+    if (!["GET", "HEAD", "OPTIONS"].includes(event.method?.toUpperCase())) {
+      throw createError({ statusCode: 405, statusMessage: "Unsupported method" });
+    } else if (event.method?.toUpperCase() === "OPTIONS") {
+      return sendNoContent(event);
+    }
+    const params = getQuery(event);
+    const page = getBoolean(params.page);
+    const collectionId = getRouterParam(event, "collectionId");
+    debugFirebaseServer(event, "api:all:[collectionId]", collectionId);
+    if (!collectionId) {
+      throw createError({ statusCode: 400, statusMessage: `collectionId is required` });
+    }
+    let query = firebaseFirestore.collection(collectionId);
+    if (event.path.startsWith("/api/instance/all")) {
+      if (!currentInstanceRef) {
+        throw createError({ statusCode: 401, statusMessage: "Missing instance" });
+      } else if (!readInstanceCollection(collectionId, event.context)) {
+        throw createError({
+          statusCode: 401,
+          statusMessage: `Can't list "instance/${collectionId}"`
+        });
+      }
+      query = currentInstanceRef.collection(collectionId);
+    } else if (!readCollection(collectionId, event.context)) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: `Can't list "${collectionId}"`
+      });
+    }
+    if (event.method?.toUpperCase() === "HEAD") {
+      setResponseStatus(event, 200);
+      return "Ok";
+    }
+    if (params.include) {
+      let include = Array.isArray(params.include) ? params.include : [params.include];
+      include = include.filter((uid) => uid && !getBoolean(uid)).map(getDocumentId);
+      debugFirebaseServer(event, "api:all:[collectionId]:filtered", include);
+      if (!include.length) return [];
+      query = query.orderBy(fieldDocument).where(fieldDocument, "in", include);
+      return getQueryAsEdges(event, query);
+    }
+    query = getOrderedQuery(event, query);
+    if (page) return getEdgesPage(event, query);
+    const first = Math.min(Number(params.first) || 10, 100);
+    return getQueryAsEdges(event, query.limit(first));
+  } catch (err) {
+    if (isError(err)) {
+      apiLogger(event, "api:all:[collectionId]", err.message, err);
+      return setResponseStatus(event, err.statusCode || 500, err.statusMessage);
+    }
+    throw err;
+  }
+});

package/dist/runtime/server/api/{media.get.d.ts → media.d.ts}

@@ -4,5 +4,5 @@
  * Buffer check because of nitro issue:
  * @see https://github.com/unjs/nitro/issues/1894
  */
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void | Buffer<ArrayBuffer>>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void | Buffer<ArrayBuffer> | "Ok">>;
 export default _default;

package/dist/runtime/server/api/{media.get.js → media.js}

@@ -7,7 +7,10 @@ import {
   getRouterParam,
   isError,
   sendError,
-  setHeaders
+  sendNoContent,
+  setHeaders,
+  setResponseHeaders,
+  setResponseStatus
 } from "h3";
 import { storageBucket } from "../utils/environment.js";
 import { debugFirebaseServer } from "../utils/firestore.js";
@@ -52,6 +55,7 @@ const cachedBufferHandler = defineCachedFunction(
         const [exists] = await file.exists();
         const headers = { "Content-Type": "image/webp" };
         if (exists) {
+          if (event.method?.toUpperCase() === "HEAD") return { headers };
           const [buffer] = await file.download();
           return { buffer, headers };
         }
@@ -83,16 +87,28 @@ const cachedBufferHandler = defineCachedFunction(
     maxAge,
     getKey(event, path) {
       const [baseAndExtension] = path.split("?");
-      return createHash("sha256").update(baseAndExtension).digest("hex");
+      const hash = createHash("sha256").update(baseAndExtension).digest("hex");
+      return `${hash}:${event.method}`;
     }
   }
 );
 export default defineEventHandler(async (event) => {
   const path = getRouterParam(event, "path") || "";
+  const Allow = "GET,HEAD";
   try {
-    const { buffer, headers, error } = await cachedBufferHandler(event, path);
-    if (headers) setHeaders(event, headers);
+    setResponseHeaders(event, { Allow, "Access-Control-Allow-Methods": Allow });
+    if (!["GET", "HEAD", "OPTIONS"].includes(event.method?.toUpperCase())) {
+      throw createError({ statusCode: 405, statusMessage: "Unsupported method" });
+    } else if (event.method?.toUpperCase() === "OPTIONS") {
+      return sendNoContent(event);
+    }
+    const { buffer, headers = {}, error } = await cachedBufferHandler(event, path);
+    setHeaders(event, headers);
     if (error || !buffer) {
+      if (!error && event.method?.toUpperCase() === "HEAD") {
+        setResponseStatus(event, 200);
+        return "Ok";
+      }
       const err = error || createError({
         statusCode: 500,
         statusMessage: `Something went wrong while trying to get file with path: "${path}"`

package/dist/runtime/server/middleware/1.context.js

@@ -18,20 +18,7 @@ export default defineEventHandler(async (event) => {
   const { firebaseFirestore } = getServerFirebase("api:middleware:context");
   const headers = getRequestHeaders(event);
   const corsHeaders = ["Origin", "Referer", "User-Agent"].join(", ");
-  if (!event.path.startsWith("/api")) {
-    setResponseHeaders(event, {
-      "Access-Control-Allow-Methods": "GET,HEAD",
-      Vary: "Host, Origin"
-    });
-    if (event.method === "OPTIONS") {
-      setResponseHeaders(event, {
-        "Access-Control-Allow-Headers": corsHeaders,
-        "Access-Control-Expose-Headers": corsHeaders
-      });
-      setResponseStatus(event, 204, "No Content");
-    }
-    return;
-  }
+  if (!event.path.startsWith("/api")) return;
   const {
     host = "",
     "x-forwarded-host": forwardedHost = host,
@@ -57,18 +44,19 @@ export default defineEventHandler(async (event) => {
       "Host",
       "Xamu-Context-Source"
     ].join(", ");
+    const Allow = "GET,HEAD,PUT,PATCH,POST,DELETE,OPTIONS";
     setResponseHeaders(event, {
-      "Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
+      Allow,
+      "Access-Control-Allow-Methods": Allow,
       "Access-Control-Allow-Credentials": "true",
       "Access-Control-Allow-Origin": corsOrigin,
       Vary: "Host, Origin"
     });
-    if (event.method === "OPTIONS") {
+    if (event.method?.toUpperCase() === "OPTIONS") {
       setResponseHeaders(event, {
         "Access-Control-Allow-Headers": corsHeadersAccept,
         "Access-Control-Expose-Headers": corsHeadersExpose
       });
-      setResponseStatus(event, 204, "No Content");
     }
     const authorization = getRequestHeader(event, "X-Forwarded-Authorization") || getRequestHeader(event, "Authorization");
     if (!authorization) return;

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

@@ -5,6 +5,8 @@ interface CachedEventHandlerOptions<T extends EventHandlerRequest = EventHandler
     getKey?: (...args: [CachedH3Event<T>]) => string | Promise<string>;
     /** Partition cache by instance */
     instanceOnly?: boolean;
+    /** Partition cache by method */
+    methodOnly?: boolean;
 }
 /**
  * Conditionally cache event data.
@@ -17,5 +19,5 @@ interface CachedEventHandlerOptions<T extends EventHandlerRequest = EventHandler
  * @param options optional key generator and instanceOnly flag
  * @returns event handler
  */
-export declare const defineConditionallyCachedEventHandler: <T extends EventHandlerRequest, D extends EventHandlerResponse = EventHandlerResponse>(handler: CachedEventHandler<T, D>, { getKey, instanceOnly }?: CachedEventHandlerOptions<T>) => CachedEventHandler<T, D>;
+export declare const defineConditionallyCachedEventHandler: <T extends EventHandlerRequest, D extends EventHandlerResponse = EventHandlerResponse>(handler: CachedEventHandler<T, D>, { getKey, instanceOnly, methodOnly }?: CachedEventHandlerOptions<T>) => CachedEventHandler<T, D>;
 export {};

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

@@ -2,16 +2,17 @@ import { defineEventHandler } from "h3";
 import { defineCachedEventHandler } from "nitropack/runtime";
 import { debugNitro } from "../utils/environment.js";
 import { sudo } from "#internal/firebase-nuxt";
-export const defineConditionallyCachedEventHandler = (handler, { getKey, instanceOnly = true } = {}) => {
+export const defineConditionallyCachedEventHandler = (handler, { getKey, instanceOnly = true, methodOnly = true } = {}) => {
   const cachedHandler = defineCachedEventHandler(handler, {
     maxAge: 30,
     // 30 seconds
-    getKey: instanceOnly ? (event) => {
+    getKey(event) {
       const { currentInstanceHost } = event.context;
-      const key = getKey?.(event) || event.path;
-      if (currentInstanceHost) return `${currentInstanceHost}:${key}`;
+      let key = getKey?.(event) || event.path;
+      if (instanceOnly && currentInstanceHost) key += `:${currentInstanceHost}`;
+      if (methodOnly) key += `:${event.method}`;
       return key;
-    } : getKey
+    }
   });
   return defineEventHandler(async (event) => {
     if (sudo(event.context) || debugNitro.value()) return handler(event);

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

@@ -9,7 +9,7 @@ export declare function debugFirebaseServer<T extends EventHandlerRequest>(event
 /**
  * This one is used on api endpoints
  */
-export declare function resolveServerDocumentRefs<T extends PseudoNode, R extends FromData<T> = FromData<T>>(event: H3Event, snapshot?: DocumentSnapshot<T, R>, collection?: string, withAuth?: boolean): Promise<R | undefined>;
+export declare function resolveServerDocumentRefs<T extends PseudoNode, R extends FromData<T> = FromData<T>>(event: H3Event, snapshot?: DocumentSnapshot<T, R>, withAuth?: boolean): Promise<R | undefined> | undefined;
 /**
  * Resolve general refs
  */

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

@@ -1,4 +1,4 @@
-import { getRequestURL, createError, getQuery } from "h3";
+import { getRequestURL, getQuery } from "h3";
 import { useEvent } from "nitropack/runtime";
 import { getBoolean, isNumberOrString } from "../utils/guards.js";
 import { makeResolveRefs } from "../../client/utils/resolver.js";
@@ -17,16 +17,13 @@ export function debugFirebaseServer(event, 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 });
+export function resolveServerDocumentRefs(event, snapshot, withAuth) {
+  if (snapshot?.exists) {
+    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);
   }
-  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();

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

@@ -25,8 +25,8 @@ export const getInstance = defineCachedFunction(
       }
     }
     const millis = snapshot.data()?.createdAt?.toMillis();
-    const instance = await resolveServerDocumentRefs(event, snapshot, "instances", false) || {};
-    if (!instance.id || !millis) {
+    const instance = await resolveServerDocumentRefs(event, snapshot, false);
+    if (!instance?.id || !millis) {
       throw createError({
         statusCode: 502,
         statusMessage: `Invalid app instance for ${host}`,
@@ -59,7 +59,7 @@ export const getRootInstance = defineCachedFunction(
     const instancesRef = firebaseFirestore.collection("instances");
     debugFirebaseServer(event, "middleware:getRootInstance");
     const snapshot = await instancesRef.doc(rootInstanceId).get();
-    return resolveServerDocumentRefs(event, snapshot, "instances", false) || {};
+    return resolveServerDocumentRefs(event, snapshot, false) || {};
   },
   {
     name: "getRootInstance",

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@open-xamu-co/firebase-nuxt",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.2",
+  "stableVersion": "1.1.0",
   "description": "Nuxt 3 module for the xamu project",
   "author": "@xamu-co",
   "type": "module",
@@ -88,6 +89,7 @@
     "@open-xamu-co/ui-common-helpers": "^4.0.0-next.2",
     "@open-xamu-co/ui-nuxt": "^4.0.0-next.6",
     "@pinia/nuxt": "^0.11.0",
+    "accept-language-parser": "^1.5.0",
     "firebase": "^11.0.2",
     "firebase-admin": "^13.6.0",
     "firebase-functions": "^7.0.3",
@@ -160,6 +162,5 @@
   },
   "browserslist": [
     "defaults"
-  ],
-  "stableVersion": "1.1.0"
+  ]
 }

package/dist/runtime/server/api/all-collection-document.get.js

@@ -1,56 +0,0 @@
-import { createError, getRouterParam, isError, setResponseStatus } from "h3";
-import { defineConditionallyCachedEventHandler } from "../utils/cache.js";
-import { debugFirebaseServer, resolveServerDocumentRefs } from "../utils/firestore.js";
-import { apiLogger, getServerFirebase } from "../utils/firebase.js";
-import { readCollection, readInstanceCollection } from "#internal/firebase-nuxt";
-export default defineConditionallyCachedEventHandler(
-  async (event) => {
-    const { firebaseFirestore } = getServerFirebase("api:all:[collectionId]:[documentId]");
-    const { currentInstanceRef } = event.context;
-    try {
-      const collectionId = getRouterParam(event, "collectionId");
-      const documentId = getRouterParam(event, "documentId");
-      debugFirebaseServer(
-        event,
-        "api:all:[collectionId]:[documentId]",
-        collectionId,
-        documentId
-      );
-      if (!collectionId || !documentId) {
-        throw createError({
-          statusCode: 400,
-          statusMessage: `collectionId & documentId are required`
-        });
-      }
-      let collectionRef = firebaseFirestore.collection(collectionId);
-      if (event.path.startsWith("/api/instance/all")) {
-        if (!currentInstanceRef) {
-          throw createError({ statusCode: 401, statusMessage: "Missing instance" });
-        } else if (!readInstanceCollection(collectionId, event.context)) {
-          throw createError({
-            statusCode: 401,
-            statusMessage: `Can't get "instance/${collectionId}" document`
-          });
-        }
-        collectionRef = currentInstanceRef.collection(collectionId);
-      } else if (!readCollection(collectionId, event.context)) {
-        throw createError({
-          statusCode: 401,
-          statusMessage: `Can't get "${collectionId}" document`
-        });
-      }
-      const documentsRef = collectionRef.doc(documentId);
-      const documentSnapshot = await documentsRef.get();
-      return resolveServerDocumentRefs(event, documentSnapshot, collectionId);
-    } catch (err) {
-      if (isError(err)) {
-        apiLogger(event, "api:all:[collectionId]:[documentId]", err.message, err);
-        return setResponseStatus(event, err.statusCode || 500, err.statusMessage);
-      }
-      throw err;
-    }
-  },
-  {
-    instanceOnly: false
-  }
-);

package/dist/runtime/server/api/all-collection.get.js

@@ -1,67 +0,0 @@
-import { FieldPath } from "firebase-admin/firestore";
-import { createError, getQuery, getRouterParam, isError, setResponseStatus } from "h3";
-import { defineConditionallyCachedEventHandler } from "../utils/cache.js";
-import { getBoolean } from "../utils/guards.js";
-import { getDocumentId } from "../../client/utils/resolver.js";
-import {
-  debugFirebaseServer,
-  getEdgesPage,
-  getOrderedQuery,
-  getQueryAsEdges
-} from "../utils/firestore.js";
-import { apiLogger, getServerFirebase } from "../utils/firebase.js";
-import { readCollection, readInstanceCollection } from "#internal/firebase-nuxt";
-export default defineConditionallyCachedEventHandler(
-  async (event) => {
-    const fieldDocument = FieldPath.documentId();
-    const { firebaseFirestore } = getServerFirebase("api:all:[collectionId]");
-    const { currentInstanceRef } = event.context;
-    try {
-      const params = getQuery(event);
-      const page = getBoolean(params.page);
-      const collectionId = getRouterParam(event, "collectionId");
-      debugFirebaseServer(event, "api:all:[collectionId]", collectionId);
-      if (!collectionId) {
-        throw createError({ statusCode: 400, statusMessage: `collectionId is required` });
-      }
-      let query = firebaseFirestore.collection(collectionId);
-      if (event.path.startsWith("/api/instance/all")) {
-        if (!currentInstanceRef) {
-          throw createError({ statusCode: 401, statusMessage: "Missing instance" });
-        } else if (!readInstanceCollection(collectionId, event.context)) {
-          throw createError({
-            statusCode: 401,
-            statusMessage: `Can't list "instance/${collectionId}"`
-          });
-        }
-        query = currentInstanceRef.collection(collectionId);
-      } else if (!readCollection(collectionId, event.context)) {
-        throw createError({
-          statusCode: 401,
-          statusMessage: `Can't list "${collectionId}"`
-        });
-      }
-      if (params.include) {
-        let include = Array.isArray(params.include) ? params.include : [params.include];
-        include = include.filter((uid) => uid && !getBoolean(uid)).map(getDocumentId);
-        debugFirebaseServer(event, "api:all:[collectionId]:filtered", include);
-        if (!include.length) return [];
-        query = query.orderBy(fieldDocument).where(fieldDocument, "in", include);
-        return getQueryAsEdges(event, query);
-      }
-      query = getOrderedQuery(event, query);
-      if (page) return getEdgesPage(event, query);
-      const first = Math.min(Number(params.first) || 10, 100);
-      return getQueryAsEdges(event, query.limit(first));
-    } catch (err) {
-      if (isError(err)) {
-        apiLogger(event, "api:all:[collectionId]", err.message, err);
-        return setResponseStatus(event, err.statusCode || 500, err.statusMessage);
-      }
-      throw err;
-    }
-  },
-  {
-    instanceOnly: false
-  }
-);