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

package/dist/runtime/composables/firestore/write.js

@@ -0,0 +1,279 @@
+import {
+  addDoc,
+  collection,
+  doc,
+  getDoc,
+  setDoc,
+  updateDoc,
+  onSnapshot,
+  arrayUnion
+} from "firebase/firestore";
+import set from "lodash-es/set";
+import { getDocumentId } from "../../client/utils/resolver.js";
+import { TimedPromise } from "../../server/utils/guards.js";
+import { useAppLogger, useInstanceStore, useNuxtApp, useSessionStore } from "#imports";
+export async function useDocumentCreate(collectionPath, partialRef, createdCallback, { omitLoggings, ...config } = { omitLoggings: false, level: 0 }) {
+  const { $clientFirestore, $resolveClientRefs } = useNuxtApp();
+  if (!collectionPath || !$clientFirestore) throw new Error("Collection path is required");
+  const SESSION = useSessionStore();
+  const INSTANCE = useInstanceStore();
+  const collRef = collection($clientFirestore, collectionPath);
+  if (collectionPath === "users") {
+    const instanceRef = doc($clientFirestore, INSTANCE.id);
+    partialRef.instancesRefs = arrayUnion(instanceRef);
+  }
+  if (SESSION.token) {
+    const memberId = getDocumentId(SESSION.path);
+    const memberPath = `${INSTANCE.id}/members/${memberId}`;
+    const createdByRef = memberId ? doc($clientFirestore, memberPath) : void 0;
+    partialRef.createdByRef = partialRef.updatedByRef = createdByRef;
+  }
+  delete partialRef.createdAt;
+  delete partialRef.updatedAt;
+  let createdRef;
+  try {
+    if (partialRef.id) {
+      createdRef = doc(collRef, getDocumentId(partialRef.id));
+      await setDoc(createdRef, partialRef, { merge: true });
+    } else createdRef = await addDoc(collRef, partialRef);
+    Promise.resolve(createdCallback?.(createdRef)).catch((err) => {
+      useAppLogger("composables:useDocumentCreate:callback", err);
+    });
+    const createdAt = /* @__PURE__ */ new Date();
+    const data = await $resolveClientRefs?.(
+      {
+        data: () => ({
+          ...partialRef,
+          id: createdRef?.path,
+          createdAt,
+          updatedAt: createdAt
+        }),
+        exists: true,
+        ref: createdRef
+      },
+      config
+    );
+    return [
+      [
+        data || false,
+        // Wait for cloud function snapshot
+        TimedPromise(
+          (resolve, reject) => {
+            if (!createdRef) return reject("No document created");
+            const unsub = onSnapshot(
+              createdRef,
+              async (snapshot) => {
+                if (!snapshot.exists()) {
+                  unsub();
+                  reject("Document was deleted after creation");
+                } else if (!snapshot.data()?.createdAt) return;
+                const finalData = await $resolveClientRefs?.(
+                  snapshot,
+                  config
+                );
+                unsub();
+                resolve(finalData || false);
+              },
+              reject
+            );
+          },
+          { fallback: false }
+        )
+      ]
+    ];
+  } catch (err) {
+    if (!omitLoggings) {
+      console.error("Error creating document", { createdRef, partialRef }, err);
+      useAppLogger("composables:useDocumentCreate", err);
+    }
+    return [false];
+  }
+}
+export async function useDocumentUpdate(node, middleRef = {}, { omitLoggings, ...config } = { omitLoggings: false, level: 0 }) {
+  const { $clientFirestore, $resolveClientRefs } = useNuxtApp();
+  if (!node.id || !$clientFirestore) throw new Error("Document id is required");
+  const SESSION = useSessionStore();
+  const INSTANCE = useInstanceStore();
+  const docRef = doc($clientFirestore, node.id || "");
+  const partialRef = middleRef;
+  const lastUpdatedAt = node.updatedAt ? new Date(node.updatedAt).getTime() : 0;
+  if (SESSION.token) {
+    const memberId = getDocumentId(SESSION.path);
+    const memberPath = `${INSTANCE.id}/members/${memberId}`;
+    const updatedByRef = memberId ? doc($clientFirestore, memberPath) : void 0;
+    partialRef.updatedByRef = updatedByRef;
+  }
+  delete partialRef.createdAt;
+  delete partialRef.updatedAt;
+  try {
+    await updateDoc(docRef, partialRef);
+    const updatedAt = /* @__PURE__ */ new Date();
+    const data = await $resolveClientRefs?.(
+      {
+        data: () => {
+          const newData = { ...partialRef, id: docRef?.path, updatedAt };
+          for (const k in newData) {
+            if (!Object.hasOwn(newData, k) || !k.includes(".")) continue;
+            set(newData, k, newData[k]);
+            delete newData[k];
+          }
+          return newData;
+        },
+        exists: true,
+        ref: docRef
+      },
+      config
+    );
+    return [
+      [
+        data || false,
+        // Wait for cloud function snapshot
+        TimedPromise(
+          (resolve, reject) => {
+            const unsub = onSnapshot(
+              docRef,
+              async (snapshot) => {
+                const updatedAt2 = snapshot.data()?.updatedAt?.toMillis() ?? 0;
+                if (lastUpdatedAt >= updatedAt2) return;
+                const finalData = await $resolveClientRefs?.(
+                  snapshot,
+                  config
+                );
+                unsub();
+                resolve(finalData || false);
+              },
+              reject
+            );
+          },
+          { fallback: false }
+        )
+      ]
+    ];
+  } catch (err) {
+    if (!omitLoggings) {
+      console.error("Error updating document", { docRef, partialRef }, err);
+      useAppLogger("composables:useDocumentUpdate", err);
+    }
+    return [false];
+  }
+}
+export async function useDocumentClone(node, middleRef = {}, { omitLoggings, ...config } = { omitLoggings: false, level: 0 }) {
+  const { $clientFirestore, $resolveClientRefs } = useNuxtApp();
+  if (!node.id || !$clientFirestore) throw new Error("Document id is required");
+  const SESSION = useSessionStore();
+  const INSTANCE = useInstanceStore();
+  const docRef = doc($clientFirestore, node.id);
+  const partialRef = middleRef;
+  const source = (await getDoc(docRef)).data();
+  if (!source) return [false];
+  if (SESSION.token) {
+    const memberId = getDocumentId(SESSION.path);
+    const memberPath = `${INSTANCE.id}/members/${memberId}`;
+    const clonedByRef = memberId ? doc($clientFirestore, memberPath) : void 0;
+    partialRef.createdByRef = partialRef.updatedByRef = clonedByRef;
+  }
+  delete source.id;
+  delete source.createdAt;
+  delete source.updatedAt;
+  delete source.lock;
+  delete partialRef.createdAt;
+  delete partialRef.updatedAt;
+  const collRef = docRef.parent;
+  let clonedDoc;
+  try {
+    clonedDoc = await addDoc(collRef, {
+      ...source,
+      ...partialRef
+    });
+    const createdAt = /* @__PURE__ */ new Date();
+    const data = await $resolveClientRefs?.(
+      {
+        data: () => ({
+          ...partialRef,
+          id: clonedDoc?.path,
+          createdAt,
+          updatedAt: createdAt
+        }),
+        exists: true,
+        ref: clonedDoc
+      },
+      config
+    );
+    return [
+      [
+        data || false,
+        // Wait for cloud function snapshot
+        TimedPromise(
+          (resolve, reject) => {
+            if (!clonedDoc) return reject("No document cloned");
+            const unsub = onSnapshot(
+              clonedDoc,
+              async (snapshot) => {
+                if (!snapshot.data()?.createdAt) return;
+                const finalData = await $resolveClientRefs?.(
+                  snapshot,
+                  config
+                );
+                unsub();
+                resolve(finalData || false);
+              },
+              reject
+            );
+          },
+          { fallback: false }
+        )
+      ]
+    ];
+  } catch (err) {
+    if (!omitLoggings) {
+      console.error("Error cloning document", { clonedDoc, partialRef }, err);
+      useAppLogger("composables:useDocumentClone", err);
+    }
+    return [false];
+  }
+}
+export async function useDocumentDelete(node, { omitLoggings } = { omitLoggings: false, level: 0 }) {
+  const { $clientFirestore } = useNuxtApp();
+  if (!node.id || !$clientFirestore) throw new Error("Document id is required");
+  const SESSION = useSessionStore();
+  const INSTANCE = useInstanceStore();
+  const docRef = doc($clientFirestore, node.id);
+  const memberId = getDocumentId(SESSION.path);
+  const memberPath = `${INSTANCE.id}/members/${memberId}`;
+  const deletedByRef = memberId ? doc($clientFirestore, memberPath) : void 0;
+  if (node.lock) return [false];
+  try {
+    await setDoc(docRef, { deletedByRef, updatedByRef: deletedByRef }, { merge: true });
+    return [
+      [
+        // Assume deleted
+        true,
+        // Wait for cloud function snapshot
+        TimedPromise(
+          (resolve, reject) => {
+            const unsub = onSnapshot(
+              docRef,
+              async (snapshot) => {
+                if (snapshot.exists()) return;
+                unsub();
+                resolve(true);
+              },
+              reject
+            );
+            setTimeout(() => {
+              unsub();
+              resolve(false);
+            }, 1e4);
+          },
+          { fallback: false }
+        )
+      ]
+    ];
+  } catch (err) {
+    if (!omitLoggings) {
+      console.error("Error deleting document", { docRef }, err);
+      useAppLogger("composables:useDocumentDelete", err);
+    }
+    return [false];
+  }
+}

package/dist/runtime/composables/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./store/app.js";
+export * from "./store/instance.js";
+export * from "./store/session.js";
+export * from "./firestore/index.js";

package/dist/runtime/composables/index.js

@@ -0,0 +1,4 @@
+export * from "./store/app.js";
+export * from "./store/instance.js";
+export * from "./store/session.js";
+export * from "./firestore/index.js";

package/dist/runtime/composables/store/app.d.ts

@@ -0,0 +1,82 @@
+interface Queue {
+    id: string;
+    message: string;
+    completed: boolean;
+}
+/**
+ * App store
+ * Handle app state
+ *
+ * @state
+ */
+export declare const useAppStore: import("pinia").StoreDefinition<"app", Pick<{
+    queue: import("vue").Ref<Queue[], Queue[]>;
+    thumbnails: import("vue").Ref<Record<string, string>, Record<string, string>>;
+    tvMQRange: import("vue").Ref<boolean, boolean>;
+    laptopMQRange: import("vue").Ref<boolean, boolean>;
+    tabletMQRange: import("vue").Ref<boolean, boolean>;
+    mobileMQRange: import("vue").Ref<boolean, boolean>;
+    smartwatchMQRange: import("vue").Ref<boolean, boolean>;
+    activeQueue: import("vue").ComputedRef<Queue[]>;
+    useQueue: <T>(id: string, message: string, toQueue: () => Promise<string | {
+        data: T;
+        message: string;
+    }>, minutes?: number) => Promise<{
+        error?: Error;
+        data?: T;
+    }>;
+    clearQueue: () => void;
+    setTvMQRange: (newValue: boolean) => void;
+    setLaptopMQRange: (newValue: boolean) => void;
+    setTabletMQRange: (newValue: boolean) => void;
+    setMobileMQRange: (newValue: boolean) => void;
+    setSmartwatchMQRange: (newValue: boolean) => void;
+    saveThumbnail: (path: string, file: File) => Promise<void>;
+}, "queue" | "thumbnails" | "tvMQRange" | "laptopMQRange" | "tabletMQRange" | "mobileMQRange" | "smartwatchMQRange">, Pick<{
+    queue: import("vue").Ref<Queue[], Queue[]>;
+    thumbnails: import("vue").Ref<Record<string, string>, Record<string, string>>;
+    tvMQRange: import("vue").Ref<boolean, boolean>;
+    laptopMQRange: import("vue").Ref<boolean, boolean>;
+    tabletMQRange: import("vue").Ref<boolean, boolean>;
+    mobileMQRange: import("vue").Ref<boolean, boolean>;
+    smartwatchMQRange: import("vue").Ref<boolean, boolean>;
+    activeQueue: import("vue").ComputedRef<Queue[]>;
+    useQueue: <T>(id: string, message: string, toQueue: () => Promise<string | {
+        data: T;
+        message: string;
+    }>, minutes?: number) => Promise<{
+        error?: Error;
+        data?: T;
+    }>;
+    clearQueue: () => void;
+    setTvMQRange: (newValue: boolean) => void;
+    setLaptopMQRange: (newValue: boolean) => void;
+    setTabletMQRange: (newValue: boolean) => void;
+    setMobileMQRange: (newValue: boolean) => void;
+    setSmartwatchMQRange: (newValue: boolean) => void;
+    saveThumbnail: (path: string, file: File) => Promise<void>;
+}, "activeQueue">, Pick<{
+    queue: import("vue").Ref<Queue[], Queue[]>;
+    thumbnails: import("vue").Ref<Record<string, string>, Record<string, string>>;
+    tvMQRange: import("vue").Ref<boolean, boolean>;
+    laptopMQRange: import("vue").Ref<boolean, boolean>;
+    tabletMQRange: import("vue").Ref<boolean, boolean>;
+    mobileMQRange: import("vue").Ref<boolean, boolean>;
+    smartwatchMQRange: import("vue").Ref<boolean, boolean>;
+    activeQueue: import("vue").ComputedRef<Queue[]>;
+    useQueue: <T>(id: string, message: string, toQueue: () => Promise<string | {
+        data: T;
+        message: string;
+    }>, minutes?: number) => Promise<{
+        error?: Error;
+        data?: T;
+    }>;
+    clearQueue: () => void;
+    setTvMQRange: (newValue: boolean) => void;
+    setLaptopMQRange: (newValue: boolean) => void;
+    setTabletMQRange: (newValue: boolean) => void;
+    setMobileMQRange: (newValue: boolean) => void;
+    setSmartwatchMQRange: (newValue: boolean) => void;
+    saveThumbnail: (path: string, file: File) => Promise<void>;
+}, "useQueue" | "clearQueue" | "setTvMQRange" | "setLaptopMQRange" | "setTabletMQRange" | "setMobileMQRange" | "setSmartwatchMQRange" | "saveThumbnail">>;
+export {};

package/dist/runtime/composables/store/app.js

@@ -0,0 +1,90 @@
+import { defineStore } from "pinia";
+import { computed, ref } from "vue";
+import { getBase64FromImageFile } from "@open-xamu-co/ui-common-helpers";
+import { TimedPromise } from "../../server/utils/guards.js";
+import { useState } from "#imports";
+export const useAppStore = defineStore("app", () => {
+  const queue = useState("app.queue", () => []);
+  const thumbnails = ref({});
+  const tvMQRange = useState("app.tvMQRange", () => false);
+  const laptopMQRange = useState("app.laptopMQRange", () => false);
+  const tabletMQRange = useState("app.tabletMQRange", () => false);
+  const mobileMQRange = useState("app.mobileMQRange", () => false);
+  const smartwatchMQRange = useState("app.smartwatchMQRange", () => false);
+  const activeQueue = computed(() => queue.value.filter((item) => !item.completed));
+  async function useQueue(id, message, toQueue, minutes = 5) {
+    let error;
+    let data;
+    try {
+      queue.value.push({ id, message, completed: false });
+      data = await TimedPromise(
+        async (resolve) => {
+          const message2 = await toQueue();
+          const queued = typeof message2 === "string" ? { message: message2 } : message2;
+          const index = queue.value.findIndex((item) => item.id === id);
+          if (queue.value[index]) {
+            queue.value[index].message = queued.message;
+            queue.value[index].completed = true;
+          }
+          resolve(queued.data);
+        },
+        { timeout: 1e3 * 60 * minutes }
+      );
+    } catch (err) {
+      error = err instanceof Error ? err : new Error("Hubo un error");
+      const index = queue.value.findIndex((item) => item.id === id);
+      if (queue.value[index]) {
+        queue.value[index].message = error.message;
+        queue.value[index].completed = true;
+      }
+    }
+    setTimeout(() => {
+      queue.value = queue.value.filter((item) => item.id !== id);
+    }, 1e3 * 60);
+    return { error, data };
+  }
+  function clearQueue() {
+    queue.value = [];
+  }
+  function setTvMQRange(newValue) {
+    tvMQRange.value = newValue;
+  }
+  function setLaptopMQRange(newValue) {
+    laptopMQRange.value = newValue;
+  }
+  function setTabletMQRange(newValue) {
+    tabletMQRange.value = newValue;
+  }
+  function setMobileMQRange(newValue) {
+    mobileMQRange.value = newValue;
+  }
+  function setSmartwatchMQRange(newValue) {
+    smartwatchMQRange.value = newValue;
+  }
+  async function saveThumbnail(path, file) {
+    const thumb = await getBase64FromImageFile(file);
+    thumbnails.value[path] = thumb;
+  }
+  const store = {
+    // App, refs
+    queue,
+    thumbnails,
+    tvMQRange,
+    laptopMQRange,
+    tabletMQRange,
+    mobileMQRange,
+    smartwatchMQRange,
+    // App, computed
+    activeQueue,
+    // App, actions
+    useQueue,
+    clearQueue,
+    setTvMQRange,
+    setLaptopMQRange,
+    setTabletMQRange,
+    setMobileMQRange,
+    setSmartwatchMQRange,
+    saveThumbnail
+  };
+  return store;
+});

package/dist/runtime/composables/store/instance.d.ts

@@ -0,0 +1,57 @@
+import type { Instance, Root } from "../../client/types/index.js";
+export interface City {
+    state?: {
+        name: string;
+    };
+    country?: {
+        name: string;
+    };
+    name: string;
+}
+/**
+ * Root instance store
+ * Handle root instance state
+ *
+ * @state
+ */
+export declare const useRootStore: import("pinia").StoreDefinition<"root", Pick<{
+    current: import("#app").CookieRef<Root | undefined>;
+    tax: import("vue").ComputedRef<number>;
+    setRoot: (newRoot?: Root) => void;
+}, "current">, Pick<{
+    current: import("#app").CookieRef<Root | undefined>;
+    tax: import("vue").ComputedRef<number>;
+    setRoot: (newRoot?: Root) => void;
+}, "tax">, Pick<{
+    current: import("#app").CookieRef<Root | undefined>;
+    tax: import("vue").ComputedRef<number>;
+    setRoot: (newRoot?: Root) => void;
+}, "setRoot">>;
+/**
+ * Instance store
+ * Handle current instance state
+ *
+ * @state
+ */
+export declare const useInstanceStore: import("pinia").StoreDefinition<"instance", Pick<{
+    fresh: import("#app").CookieRef<boolean>;
+    current: import("#app").CookieRef<Instance | undefined>;
+    location: import("#app").CookieRef<string | undefined>;
+    id: import("vue").ComputedRef<string>;
+    setInstance: (instance?: Instance) => Promise<void>;
+    unsetInstance: () => void;
+}, "location" | "current" | "fresh">, Pick<{
+    fresh: import("#app").CookieRef<boolean>;
+    current: import("#app").CookieRef<Instance | undefined>;
+    location: import("#app").CookieRef<string | undefined>;
+    id: import("vue").ComputedRef<string>;
+    setInstance: (instance?: Instance) => Promise<void>;
+    unsetInstance: () => void;
+}, "id">, Pick<{
+    fresh: import("#app").CookieRef<boolean>;
+    current: import("#app").CookieRef<Instance | undefined>;
+    location: import("#app").CookieRef<string | undefined>;
+    id: import("vue").ComputedRef<string>;
+    setInstance: (instance?: Instance) => Promise<void>;
+    unsetInstance: () => void;
+}, "setInstance" | "unsetInstance">>;

package/dist/runtime/composables/store/instance.js

@@ -0,0 +1,94 @@
+import { defineStore, skipHydrate } from "pinia";
+import { omit } from "lodash-es";
+import { computed } from "vue";
+import { makeLogger } from "../../client/utils/logger.js";
+import { useCookie, useRuntimeConfig } from "#imports";
+const cookieOptionsDefaults = {
+  sameSite: "strict",
+  maxAge: 60 * 60
+  // 1 hour
+};
+export const useRootStore = defineStore("root", () => {
+  const { production } = useRuntimeConfig().public;
+  const cookieOptions = {
+    ...cookieOptionsDefaults,
+    secure: production,
+    partitioned: production
+  };
+  const current = useCookie("root.current", {
+    ...cookieOptions,
+    default: () => void 0
+  });
+  const tax = computed(() => {
+    return (current.value?.config?.iva ?? 19) / 100 + 1;
+  });
+  function setRoot(newRoot) {
+    if (!newRoot) return;
+    current.value = newRoot;
+  }
+  return {
+    // State
+    current: skipHydrate(current),
+    // Getters
+    tax,
+    // Actions
+    setRoot
+  };
+});
+export const useInstanceStore = defineStore("instance", () => {
+  const { production, cache } = useRuntimeConfig().public;
+  const cookieOptions = {
+    ...cookieOptionsDefaults,
+    secure: production,
+    partitioned: production
+  };
+  const current = useCookie("instance.current", {
+    ...cookieOptions,
+    default: () => void 0
+  });
+  const location = useCookie("instance.location", {
+    ...cookieOptions,
+    default: () => void 0
+  });
+  const fresh = useCookie("instance.fresh", {
+    ...omit(cookieOptions, "maxAge"),
+    default: () => false
+  });
+  const id = computed(() => current.value?.id || "");
+  async function setInstance(instance) {
+    if (!instance) return;
+    const url = instance.url;
+    const logger = makeLogger({ instanceId: id.value });
+    const { locationCountry, locationState, locationCity } = instance;
+    current.value = { ...instance, url };
+    if (fresh.value || !locationCountry || !locationState || !locationCity) return;
+    const endpoint = `${url}/_countries/${locationCountry}/${locationState}/${locationCity}`;
+    fresh.value = true;
+    try {
+      const { data } = await $fetch(endpoint, {
+        query: { state: true, country: true },
+        headers: { "Cache-Control": cache.longterm }
+      });
+      if (!data) return;
+      location.value = `${data.name}. ${data.state?.name}. ${data.country?.name}.`;
+    } catch (err) {
+      logger("composables:useInstanceStore:setInstance", err);
+    }
+  }
+  function unsetInstance() {
+    location.value = void 0;
+    current.value = void 0;
+    fresh.value = false;
+  }
+  return {
+    // Instance
+    fresh: skipHydrate(fresh),
+    current: skipHydrate(current),
+    location: skipHydrate(location),
+    // Getters
+    id,
+    // Actions
+    setInstance,
+    unsetInstance
+  };
+});

package/dist/runtime/composables/store/session.d.ts

@@ -0,0 +1,41 @@
+import { type Auth } from "firebase/auth";
+import type { InstanceMember, User } from "../../client/types/index.js";
+interface iSessionUser extends User, Omit<InstanceMember, "user"> {
+}
+/**
+ * Session store
+ * Handle authentication state
+ *
+ * Token is to large, so this store should handle its own cookie
+ *
+ * @state
+ */
+export declare const useSessionStore: import("pinia").StoreDefinition<"session", Pick<{
+    token: import("#app").CookieRef<string | null>;
+    expiredToken: import("#app").CookieRef<boolean>;
+    user: import("#app").CookieRef<iSessionUser | undefined>;
+    path: import("vue").ComputedRef<string>;
+    setUser: ({ createdAt, updatedAt, ...userData }: User, token: string) => void;
+    unsetSession: (expiredToken?: boolean) => void;
+    logout: (clientAuth?: Auth) => Promise<void>;
+    remove: (clientAuth?: Auth) => Promise<void>;
+}, "user" | "token" | "expiredToken">, Pick<{
+    token: import("#app").CookieRef<string | null>;
+    expiredToken: import("#app").CookieRef<boolean>;
+    user: import("#app").CookieRef<iSessionUser | undefined>;
+    path: import("vue").ComputedRef<string>;
+    setUser: ({ createdAt, updatedAt, ...userData }: User, token: string) => void;
+    unsetSession: (expiredToken?: boolean) => void;
+    logout: (clientAuth?: Auth) => Promise<void>;
+    remove: (clientAuth?: Auth) => Promise<void>;
+}, "path">, Pick<{
+    token: import("#app").CookieRef<string | null>;
+    expiredToken: import("#app").CookieRef<boolean>;
+    user: import("#app").CookieRef<iSessionUser | undefined>;
+    path: import("vue").ComputedRef<string>;
+    setUser: ({ createdAt, updatedAt, ...userData }: User, token: string) => void;
+    unsetSession: (expiredToken?: boolean) => void;
+    logout: (clientAuth?: Auth) => Promise<void>;
+    remove: (clientAuth?: Auth) => Promise<void>;
+}, "remove" | "setUser" | "unsetSession" | "logout">>;
+export {};