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

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

@@ -0,0 +1,89 @@
+import { deleteUser } from "firebase/auth";
+import { defineStore, skipHydrate } from "pinia";
+import { computed } from "vue";
+import { useRouter } from "vue-router";
+import { getDocumentId } from "../../client/utils/resolver.js";
+import { useCookie, useRuntimeConfig, useSwal } from "#imports";
+const cookieOptionsDefaults = {
+  sameSite: "strict",
+  maxAge: 365 * 24 * 60 * 60
+  // 1 year
+};
+export const useSessionStore = defineStore("session", () => {
+  const { production } = useRuntimeConfig().public;
+  const cookieOptions = {
+    ...cookieOptionsDefaults,
+    secure: production,
+    partitioned: production
+  };
+  const token = useCookie("session.token", {
+    ...cookieOptions,
+    default: () => null
+  });
+  const expiredToken = useCookie("session.expiredToken", {
+    ...cookieOptions,
+    default: () => false
+  });
+  const user = useCookie("session.user", {
+    ...cookieOptions,
+    partitioned: false,
+    default: () => void 0
+  });
+  const path = computed(() => {
+    const id = user.value?.id;
+    return id ? `users/${getDocumentId(id)}` : "";
+  });
+  function setToken(newToken, newExpiredToken = false) {
+    token.value = newToken || null;
+    expiredToken.value = newExpiredToken;
+  }
+  function setUser({ createdAt, updatedAt, ...userData }, token2) {
+    user.value = { ...user.value, ...userData };
+    setToken(token2, false);
+  }
+  function unsetSession(expiredToken2 = false) {
+    setToken("", expiredToken2);
+    user.value = void 0;
+  }
+  async function logout(clientAuth) {
+    if (import.meta.server) return;
+    const Swal = useSwal();
+    const { value } = await Swal.firePrevent({
+      title: "Cerrar sesion",
+      text: "\xBFEsta seguro de querer cerrar sesion?"
+    });
+    if (value) {
+      unsetSession();
+      await clientAuth?.signOut();
+      window.location.href = "/";
+    }
+  }
+  async function remove(clientAuth) {
+    if (import.meta.server) return;
+    const router = useRouter();
+    const Swal = useSwal();
+    const { value } = await Swal.firePrevent({
+      title: "Eliminar cuenta",
+      text: "\xBFEsta seguro de querer eliminar tu cuenta?",
+      footer: "Borraremos toda tu informaci\xF3n, esta acci\xF3n no es reversible, aunque puedes volver a registrarte mas tarde"
+    });
+    const user2 = clientAuth?.currentUser;
+    if (user2 && value) {
+      await deleteUser(user2);
+      router.push("/");
+    }
+  }
+  return {
+    // User
+    token: skipHydrate(token),
+    expiredToken: skipHydrate(expiredToken),
+    user: skipHydrate(user),
+    // User getters
+    path,
+    // User actions
+    setUser,
+    unsetSession,
+    logout,
+    remove
+  };
+});

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

@@ -0,0 +1,2 @@
+import type { tLogger } from "@open-xamu-co/ui-common-types";
+export default function useAppLogger(...args: Parameters<tLogger>): Promise<any>;

package/dist/runtime/composables/useAppLogger.js

@@ -0,0 +1,8 @@
+import { makeLogger } from "../client/utils/logger.js";
+import { useInstanceStore, useSessionStore } from "#imports";
+export default async function useAppLogger(...args) {
+  const INSTANCE = useInstanceStore();
+  const SESSION = useSessionStore();
+  const logger = makeLogger({ instanceId: INSTANCE.id, authId: SESSION.path });
+  return logger(...args);
+}

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

@@ -0,0 +1,19 @@
+import { DocumentReference } from "firebase/firestore";
+interface UploadOptions {
+    type?: "images";
+    customMetadata?: Record<string, any>;
+    /**
+     * File upload callback
+     *
+     * Runs if not all files were uploaded
+     */
+    uploaded?: (paths: string[]) => any;
+}
+/**
+ * upload files, get urls
+ *
+ * Files should not bother with instances
+ */
+export default function useFilesUpload(files: File[] | undefined, targetRef: DocumentReference, // Document related to the files
+options?: UploadOptions): Promise<string[]>;
+export {};

package/dist/runtime/composables/useFilesUpload.js

@@ -0,0 +1,110 @@
+import { toRaw } from "vue";
+import { collection, doc, getDoc, increment, setDoc } from "firebase/firestore";
+import { getToken } from "firebase/app-check";
+import { getDocumentId } from "../client/utils/resolver.js";
+import useAppLogger from "./useAppLogger.js";
+import {
+  useNuxtApp,
+  useAppStore,
+  useInstanceStore,
+  useSessionStore,
+  useRuntimeConfig
+} from "#imports";
+export default async function useFilesUpload(files = [], targetRef, options = {}) {
+  const APP = useAppStore();
+  const SESSION = useSessionStore();
+  const INSTANCE = useInstanceStore();
+  const { $clientFirestore, $clientAppCheck } = useNuxtApp();
+  const { firebaseConfig } = useRuntimeConfig().public;
+  const appData = toRaw(firebaseConfig);
+  const { type = "images", customMetadata = {}, uploaded } = options;
+  if (!SESSION.token || !$clientFirestore || !$clientAppCheck) {
+    throw new Error("Subida no autorizada");
+  }
+  const memberId = getDocumentId(SESSION.path);
+  const memberPath = `${INSTANCE.id}/members/${memberId}`;
+  const updatedByRef = memberId ? doc($clientFirestore, memberPath) : void 0;
+  const parentCollection = targetRef.parent;
+  const grandParentDocument = parentCollection.parent;
+  const counterPath = grandParentDocument?.path || INSTANCE.id;
+  const countersCollectionRef = collection($clientFirestore, `${counterPath}/counters`);
+  const counterId = `${type}_${parentCollection.id}_${targetRef.id}`;
+  const counterRef = doc(countersCollectionRef, counterId);
+  const counterSnapshot = await getDoc(counterRef);
+  const { current = 0, createdByRef = updatedByRef } = counterSnapshot.data() || {};
+  const { token: appCheckToken } = await getToken($clientAppCheck);
+  try {
+    setDoc(
+      counterRef,
+      { current: increment(files.length), createdByRef, updatedByRef },
+      { merge: true }
+    );
+  } catch (err) {
+    useAppLogger("composables:files:useFilesUpload:counter", counterRef.path, err);
+  }
+  const paths = [];
+  for (let index = 0; index < files.length; index++) {
+    const file = files[index];
+    const path = `${targetRef.path}_${current + index + 1}`;
+    const filePath = `${type}/${path}/original.${file.type.split("/")[1]}`;
+    const id = `${targetRef.id}_${file.name}`;
+    if (!file.size) {
+      useAppLogger("composables:files:useFilesUpload:map", new Error("Invalid file"), {
+        path,
+        size: file.size,
+        type: file.type,
+        name: file.name,
+        lastModified: file.lastModified
+      });
+      continue;
+    }
+    paths.push(path);
+    await APP.saveThumbnail(path, file);
+    APP.useQueue(
+      id,
+      `Subiendo archivo`,
+      async () => {
+        try {
+          const worker = new Worker("/js/file-upload.js", { type: "module" });
+          const uploadedSize = await new Promise((resolve, reject) => {
+            worker.postMessage({
+              filePath,
+              file,
+              customMetadata: { filePath, memberPath, ...customMetadata },
+              appData,
+              appCheckToken
+            });
+            worker.onmessage = ({ data }) => {
+              const { result, error, message, type: type2 } = data;
+              switch (type2) {
+                case "result":
+                  resolve(result);
+                  break;
+                case "message":
+                  console.log(message);
+                  break;
+                case "error":
+                  console.log(message, error);
+                  reject(error);
+                  break;
+              }
+            };
+            worker.onerror = (err) => reject(err);
+            worker.onmessageerror = (err) => reject(err);
+          });
+          if (!uploadedSize) throw `No se subi\xF3 el archivo ${id}`;
+          await new Promise((resolve) => setTimeout(resolve, 1e3 * 10));
+          return `Archivo subido (${(uploadedSize / 1e6).toFixed(2)}MB)`;
+        } catch (err) {
+          paths.splice(paths.indexOf(path), 1);
+          uploaded?.(paths);
+          useAppLogger("composables:files:useFilesUpload:upload", path, err);
+          throw `No se subi\xF3 el archivo ${id}`;
+        }
+      },
+      10
+      // Minutes per upload
+    );
+  }
+  return paths;
+}

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

@@ -0,0 +1,9 @@
+import { type iPriceProps } from "../functions/utils/price.js";
+export default function usePrice(props?: iPriceProps): {
+    iva: number;
+    base: number;
+    price: number;
+    formattedIva: string;
+    formattedBase: string;
+    formattedPrice: string;
+};

package/dist/runtime/composables/usePrice.js

@@ -0,0 +1,6 @@
+import { makeUsePrice } from "../functions/utils/price.js";
+import { useRootStore } from "#imports";
+export default function usePrice(props) {
+  const ROOT = useRootStore();
+  return makeUsePrice(ROOT.tax)(props);
+}

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

@@ -0,0 +1,12 @@
+import type { NitroFetchOptions, NitroFetchRequest } from "nitropack";
+/**
+ * Fetch wrapper with csrf token
+ */
+export declare function useCsrfQuery<T, R extends NitroFetchRequest = NitroFetchRequest>(url: Extract<R, string>, baseOptions?: NitroFetchOptions<R>): Promise<any>;
+/**
+ * Fetch wrapper
+ *
+ * Refresh auth token before each request
+ * @see https://stackoverflow.com/questions/47803495/error-firebase-id-token-has-expired
+ */
+export declare function useQuery<T, R extends NitroFetchRequest = NitroFetchRequest>(url: Extract<R, string>, baseOptions?: NitroFetchOptions<R>): Promise<import("nitropack").TypedInternalResponse<NitroFetchRequest, T, "get">>;

package/dist/runtime/composables/useQuery.js

@@ -0,0 +1,33 @@
+import { useRequestHeaders, useNuxtApp, useRuntimeConfig, useSessionStore } from "#imports";
+async function getQueryOptions(baseOptions) {
+  const SESSION = useSessionStore();
+  const { $clientAuth } = useNuxtApp();
+  const { cache } = useRuntimeConfig().public;
+  const { query, ...options } = { ...baseOptions };
+  const headers = {
+    ...useRequestHeaders(),
+    // Server headers (required for instance)
+    authorization: SESSION.token || "",
+    "Cache-Control": cache.frequent,
+    ...options?.headers,
+    // Overrides
+    "Xamu-Context-Source": import.meta.client ? "client" : "server"
+  };
+  if (SESSION.user) {
+    if (import.meta.client) {
+      const freshToken = await $clientAuth?.currentUser?.getIdToken();
+      headers.authorization = freshToken || headers.authorization;
+    }
+    SESSION.setUser(SESSION.user, headers.authorization);
+  }
+  return { credentials: "same-origin", ...options, query, headers };
+}
+export async function useCsrfQuery(url, baseOptions) {
+  const { $csrfFetch } = useNuxtApp();
+  const { responseType, ...options } = await getQueryOptions(baseOptions);
+  return $csrfFetch(url, options);
+}
+export async function useQuery(url, baseOptions) {
+  const options = await getQueryOptions(baseOptions);
+  return $fetch(url, options);
+}

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

@@ -0,0 +1,14 @@
+export declare function useImagePath(path?: string, preset?: "avatar" | "small" | "medium" | "large"): string;
+/**
+ * Return object with differing properties if any
+ */
+export declare function getValuesDiff<V extends Record<string, any>>(values: V, expectedValues: Partial<V>): Partial<V> | undefined;
+export declare function useCreateError(message: string, statusCode?: number): import("nuxt/app").NuxtError<unknown>;
+/**
+ * Append tracking information to external urls
+ */
+export declare function useUTMLink(link: string): string;
+/**
+ * Attemp to reload image after a few seconds
+ */
+export declare function onImageError(event: Event, attemp?: number): string | undefined;

package/dist/runtime/composables/utils.js

@@ -0,0 +1,65 @@
+import { isEqual } from "lodash-es";
+import { createError, useAppStore, useInstanceStore } from "#imports";
+export function useImagePath(path, preset = "avatar") {
+  if (!path || path === "/sample-loading.png") return "/sample-loading.png";
+  else if (path.startsWith("/api/media/images")) return path;
+  else if (path.startsWith("/firebase")) path = path.replace("/firebase", "/api/media/images");
+  else path = `/api/media/images/${path}/${preset}.webp`;
+  return `${path}?temp=${Date.now()}`;
+}
+export function getValuesDiff(values, expectedValues) {
+  const keysWithDifference = [];
+  const differentValues = {};
+  for (const k in expectedValues) {
+    if (!Object.hasOwn(expectedValues, k)) continue;
+    const expected = ![null, void 0, ""].includes(expectedValues[k]);
+    const provided = values[k] || values[k] === 0;
+    if (k in values || expected && !provided) {
+      const equal = isEqual(values[k], expectedValues[k]);
+      const emptyArray = isEqual(values[k] || [], expectedValues[k]);
+      if (equal || emptyArray) continue;
+      keysWithDifference.push(k);
+      differentValues[k] = values[k] ?? "";
+    }
+  }
+  if (!keysWithDifference.length) return;
+  return differentValues;
+}
+export function useCreateError(message, statusCode = 500) {
+  return createError({ message, statusCode, fatal: true });
+}
+export function useUTMLink(link) {
+  const INSTANCE = useInstanceStore();
+  const { hostname } = new URL(INSTANCE.current?.url || "");
+  const url = new URL(link);
+  url.searchParams.append("utm_source", hostname);
+  url.searchParams.append("utm_content", "textlink");
+  return url.toString();
+}
+export function onImageError(event, attemp = 0) {
+  if (attemp >= 20) return;
+  const APP = useAppStore();
+  const img = event.target;
+  const [src] = img.src.split("?");
+  if (src.includes("/api/media/images/instances/")) {
+    const key = src.slice(18, src.lastIndexOf("/"));
+    const thumbnail = APP.thumbnails[key];
+    if (thumbnail) return img.src = thumbnail;
+  }
+  setTimeout(async () => {
+    try {
+      const now = Date.now();
+      const unchached = `${src}?t=${now}`;
+      const response = await fetch(src);
+      if (!response.ok) {
+        if (response.status === 503 || response.status === 404) {
+          return onImageError(event, attemp++);
+        }
+        return;
+      }
+      img.src = unchached;
+    } catch (error) {
+      return;
+    }
+  }, 1e3 * 5);
+}

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

@@ -0,0 +1,56 @@
+import type { FieldValue, Timestamp } from "firebase-admin/firestore";
+import type { ePaymentValidator } from "../../utils/enums.js";
+export type FirebaseValues<T extends FirebaseData> = {
+    [K in keyof T]?: T[K] | FieldValue;
+};
+/**
+ * Extended firebase DocumentData
+ *
+ * @abstract
+ */
+export interface FirebaseData extends Record<string, any> {
+    /** @automated Creation date */
+    createdAt?: Timestamp;
+    /** @automated Last update date */
+    updatedAt?: Timestamp;
+    /**
+     * Lock document & prevent deletion
+     * A boolean or an array of reference paths locking the document
+     *
+     * @automated
+     */
+    lock?: boolean | string[];
+}
+/**
+ * Price data
+ *
+ * @abstract
+ */
+export interface PriceData {
+    /** Full price */
+    price?: number;
+    /** base price (no iva) */
+    base?: number;
+    /** Iva price */
+    iva?: number;
+    /** @automated unique item ref */
+    reference?: string;
+}
+/**
+ * Payment data
+ *
+ * @abstract
+ */
+export interface PaymentData extends PriceData {
+    /** @automated Integrity hash */
+    integrity?: string;
+    /** @automated Payment validation source */
+    validator?: ePaymentValidator;
+    /**
+     * Client has paid
+     * @automated Payment date
+     */
+    paidAt?: false | Timestamp;
+    observations?: string;
+    oldObservations?: string;
+}

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

@@ -0,0 +1,73 @@
+import type { DocumentReference } from "firebase-admin/firestore";
+import type { FirebaseData } from "./base.js";
+import type { LogData } from "./logs.js";
+import type { UserData } from "./user.js";
+/**
+ * Document can be modified by any user
+ *
+ * This data is used to keep track of the changes
+ */
+export interface SharedData extends FirebaseData {
+    createdByRef?: DocumentReference;
+    updatedByRef?: DocumentReference;
+    deletedByRef?: DocumentReference;
+}
+/**
+ * Root instance
+ * Stores data that is shared across all instances
+ *
+ * @collection instances
+ */
+export interface RootData extends InstanceData {
+    config?: InstanceData["config"] & {
+        /**
+         * IVA percentage
+         * Keep track of the IVA percentage
+         * @example 19
+         */
+        iva?: number;
+    };
+    /** @example "Xamu" */
+    poweredBy?: string;
+}
+/**
+ * App instance
+ *
+ * @collection instances
+ */
+export interface InstanceData extends SharedData {
+    locationCity?: string;
+    locationState?: string;
+    locationCountry?: string;
+    /**
+     * Canonical site url
+     *
+     * @example https://my-store.mydomain.com
+     * @automated
+     */
+    url?: string;
+    config?: {
+        [key: string]: any;
+        /**
+         * When tenants are enabled, domains are required
+         */
+        domains?: string[];
+    };
+}
+/**
+ * Firebase log
+ *
+ * @collection instances/logs
+ */
+export interface InstanceLogData extends LogData, SharedData {
+}
+/**
+ * Instance member
+ *
+ * @collection instances/members
+ */
+export interface InstanceMemberData extends SharedData {
+    userRef?: DocumentReference<UserData>;
+    /** Could be non existent */
+    rootMemberRef?: DocumentReference<InstanceMemberData>;
+}

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

@@ -0,0 +1,15 @@
+import type { FirebaseData } from "./base.js";
+/** General log entity */
+export interface LogData extends FirebaseData {
+    at?: string;
+    code?: string;
+    message?: string;
+    error?: string;
+    /** Additional log tracking metadata */
+    metadata?: any;
+    /**
+     * Internal logs, omit some automation
+     * @automated
+     */
+    internal?: boolean;
+}

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

@@ -0,0 +1,13 @@
+import type { SharedData } from "./instance.js";
+/**
+ * Firebase user
+ *
+ * @collection
+ */
+export interface UserData extends SharedData {
+    uid?: string;
+    photoURL?: string | null;
+    isAnonymous?: boolean | null;
+    name?: string | null;
+    email?: string | null;
+}

package/dist/runtime/functions/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./entities/base.js";
+export * from "./entities/user.js";
+export * from "./entities/instance.js";
+export * from "./entities/logs.js";

package/dist/runtime/functions/types/index.js

@@ -0,0 +1,4 @@
+export * from "./entities/base.js";
+export * from "./entities/user.js";
+export * from "./entities/instance.js";
+export * from "./entities/logs.js";

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

@@ -0,0 +1,24 @@
+/**
+ * Encrypts a given text using AES-256-CBC algorithm.
+ *
+ * This function takes in a text to be encrypted and an encryption key.
+ * It generates a random initialization vector (IV) and uses it along with the key to create a cipher.
+ * The text is then encrypted using the cipher and the encrypted text is concatenated with the IV.
+ *
+ * @param {string} text - The text to be encrypted.
+ * @param {string} key - The encryption key.
+ * @returns {string} The encrypted text, concatenated with the initialization vector.
+ */
+export declare function encrypt(text: string, key: string): string;
+/**
+ * Decrypts a given encrypted text using AES-256-CBC algorithm.
+ *
+ * This function takes in an encrypted text and an encryption key.
+ * It splits the encrypted text into the initialization vector (IV) and the actual encrypted text.
+ * It then uses the IV and the key to create a decipher and decrypts the text.
+ *
+ * @param {string} text - The encrypted text to be decrypted.
+ * @param {string} key - The encryption key.
+ * @returns {string} The decrypted text.
+ */
+export declare function decrypt(text: string, key: string): string;

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

@@ -0,0 +1,17 @@
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+export function encrypt(text, key) {
+  const iv = randomBytes(16);
+  const cipher = createCipheriv("aes-256-cbc", Buffer.from(key.padEnd(32, "0")), iv);
+  let encrypted = cipher.update(text);
+  encrypted = Buffer.concat([encrypted, cipher.final()]);
+  return iv.toString("hex") + ":" + encrypted.toString("hex");
+}
+export function decrypt(text, key) {
+  const parts = text.split(":");
+  const iv = Buffer.from(parts.shift(), "hex");
+  const encryptedText = Buffer.from(parts.join(":"), "hex");
+  const decipher = createDecipheriv("aes-256-cbc", Buffer.from(key.padEnd(32, "0")), iv);
+  let decrypted = decipher.update(encryptedText);
+  decrypted = Buffer.concat([decrypted, decipher.final()]);
+  return decrypted.toString();
+}

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

@@ -0,0 +1,40 @@
+export declare enum eIdDocumentType {
+    /** Cédula de ciudadanía */
+    CC = "CC",
+    /** Cédula de extranjería */
+    CE = "CE",
+    /** Pasaporte */
+    PA = "PA",
+    /** Tarjeta de identidad */
+    TI = "TI",
+    /** Numero de identificación tributario */
+    NIT = "NIT"
+}
+/**
+ * Purchase validation source
+ */
+export declare enum ePaymentValidator {
+    /** Gateway did its job */
+    WEBHOOK = "WEBHOOK",
+    /** Timeout elapsep */
+    TIMEOUT_TASK = "TIMEOUT_TASK",
+    /** User returned from gateway */
+    TURNBACK = "TURNBACK",
+    /** Admin handled the charge */
+    ADMIN = "ADMIN"
+}
+/**
+ * Cache control
+ */
+export declare enum eCacheControl {
+    NONE = "no-cache, no-store, must-revalidate",
+    /** Cache for a few minutes */
+    FREQUENT = "public, max-age=120, stale-while-revalidate=60",
+    /** Cache for an hour */
+    NORMAL = "public, max-age=3600, must-revalidate",
+    /** Cache for a month */
+    MIDTERM = "public, max-age=2592000, must-revalidate",
+    /** Cache for a year */
+    LONGTERM = "public, max-age=31536000, must-revalidate"
+}
+export {};

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

@@ -0,0 +1,24 @@
+export var eIdDocumentType = /* @__PURE__ */ ((eIdDocumentType2) => {
+  eIdDocumentType2["CC"] = "CC";
+  eIdDocumentType2["CE"] = "CE";
+  eIdDocumentType2["PA"] = "PA";
+  eIdDocumentType2["TI"] = "TI";
+  eIdDocumentType2["NIT"] = "NIT";
+  return eIdDocumentType2;
+})(eIdDocumentType || {});
+export var ePaymentValidator = /* @__PURE__ */ ((ePaymentValidator2) => {
+  ePaymentValidator2["WEBHOOK"] = "WEBHOOK";
+  ePaymentValidator2["TIMEOUT_TASK"] = "TIMEOUT_TASK";
+  ePaymentValidator2["TURNBACK"] = "TURNBACK";
+  ePaymentValidator2["ADMIN"] = "ADMIN";
+  return ePaymentValidator2;
+})(ePaymentValidator || {});
+export var eCacheControl = /* @__PURE__ */ ((eCacheControl2) => {
+  eCacheControl2["NONE"] = "no-cache, no-store, must-revalidate";
+  eCacheControl2["FREQUENT"] = "public, max-age=120, stale-while-revalidate=60";
+  eCacheControl2["NORMAL"] = "public, max-age=3600, must-revalidate";
+  eCacheControl2["MIDTERM"] = "public, max-age=2592000, must-revalidate";
+  eCacheControl2["LONGTERM"] = "public, max-age=31536000, must-revalidate";
+  return eCacheControl2;
+})(eCacheControl || {});
+export {};