@goweekdays/layer-common 0.0.1

package/composables/useUtils.ts

@@ -0,0 +1,150 @@
+export default function useUtils() {
+  const requiredRule = (v: string) => !!v || "Required";
+
+  const emailRule = (v: string): true | string => {
+    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return regex.test(v) || "Please enter a valid email address";
+  };
+
+  const passwordRule = (v: string) =>
+    v.length >= 8 || "Password must be at least 8 characters long";
+
+  const confirmPasswordRule =
+    (newPassword: Ref<string>, confirmPassword: Ref<string>) => () =>
+      confirmPassword.value === newPassword.value || "Passwords must match";
+
+  const validateEmail = (email: Ref<string>, emailErrors: Ref<string[]>) => {
+    emailErrors.value = [];
+
+    if (!email.value) {
+      emailErrors.value.push("Please input your email");
+    } else {
+      const result = emailRule(email.value);
+      if (result !== true) {
+        emailErrors.value.push(result);
+      }
+    }
+  };
+
+  const validateWord = (value: string): boolean | string => {
+    if (value.trim().length < 3) return "Must be at least 3 characters";
+    return true;
+  };
+
+  const validatePassword = (
+    password: Ref<string>,
+    passwordErrors: Ref<string[]>
+  ) => {
+    passwordErrors.value = [];
+
+    if (!password.value) {
+      passwordErrors.value.push("Please input your password");
+    } else if (!passwordRule(password.value)) {
+      passwordErrors.value.push("Password must be at least 8 characters long");
+    }
+  };
+
+  function back() {
+    useRouter().back();
+  }
+
+  function debounce<T extends (...args: any[]) => void>(
+    func: T,
+    wait: number
+  ): (...args: Parameters<T>) => void {
+    let timeoutId: ReturnType<typeof setTimeout>;
+
+    return function (...args: Parameters<T>) {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => func(...args), wait);
+    };
+  }
+
+  function insertBetween(arr: any, elementToInsert: any) {
+    return arr.flatMap((item: any, index: number, array: any) =>
+      index < array.length - 1 ? [item, elementToInsert] : [item]
+    );
+  }
+
+  function getNameInitials(name: string) {
+    if (typeof name !== "string" || name.trim() === "") {
+      return ""; // Default fallback for invalid input
+    }
+
+    const initials = name
+      .trim()
+      .split(/\s+/) // Split by spaces
+      .map((word) => word[0]?.toUpperCase()) // Take the first letter of each word and capitalize
+      .join(""); // Combine all initials
+
+    return initials.slice(0, 2); // Limit to 2 characters
+  }
+
+  function getDimensions(
+    file: File
+  ): Promise<{ width: number; height: number }> {
+    const img = new Image();
+    img.src = URL.createObjectURL(file);
+    return new Promise((resolve, reject) => {
+      img.onload = () => {
+        const width = img.width;
+        const height = img.height;
+        resolve({ width, height });
+      };
+
+      img.onerror = () => {
+        reject(new Error("Failed to read image dimensions"));
+      };
+    });
+  }
+
+  async function getCountries() {
+    try {
+      const countries = await useNuxtApp().$api<Array<Record<string, any>>>(
+        "https://restcountries.com/v3.1/all",
+        { method: "GET" }
+      );
+
+      const uniqueCountries = new Map();
+
+      countries.forEach((country) => {
+        let suffixes = country.idd?.suffixes?.[0] || "";
+        let code = `${country.idd?.root || ""}${suffixes}`;
+        let name = country.name?.common || "";
+
+        if (name && code && !uniqueCountries.has(code)) {
+          uniqueCountries.set(code, { index: `${name}-${code}`, name, code });
+        }
+      });
+
+      return Array.from(uniqueCountries.values()).sort((a, b) =>
+        a.name.localeCompare(b.name)
+      );
+    } catch (error) {
+      console.error(error);
+      throw new Error("Failed to fetch countries.");
+    }
+  }
+
+  const formatter = new Intl.NumberFormat("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  });
+
+  return {
+    requiredRule,
+    emailRule,
+    passwordRule,
+    confirmPasswordRule,
+    validateEmail,
+    validatePassword,
+    back,
+    debounce,
+    insertBetween,
+    getNameInitials,
+    getDimensions,
+    validateWord,
+    getCountries,
+    formatter,
+  };
+}

package/composables/useVerification.ts

@@ -0,0 +1,18 @@
+export default function useUser() {
+  function getVerifications({
+    status = "pending",
+    type = "user-invite",
+    search = "",
+    page = 1,
+    email = "",
+  } = {}) {
+    return useNuxtApp().$api<TKeyValuePair>("/api/verifications", {
+      method: "GET",
+      query: { status, search, page, type, email },
+    });
+  }
+
+  return {
+    getVerifications,
+  };
+}

package/eslint.config.js

@@ -0,0 +1,3 @@
+import withNuxt from './.playground/.nuxt/eslint.config.mjs'
+
+export default withNuxt()

package/nuxt.config.ts

@@ -0,0 +1,46 @@
+// https://nuxt.com/docs/api/configuration/nuxt-config
+import vuetify, { transformAssetUrls } from "vite-plugin-vuetify";
+export default defineNuxtConfig({
+  devtools: { enabled: true },
+  build: {
+    transpile: ["vuetify"],
+  },
+
+  runtimeConfig: {
+    public: {
+      cookieConfig: {
+        domain: (process.env.DOMAIN as string) ?? "localhost",
+        secure: true,
+        maxAge: 30 * 24 * 60 * 60,
+      },
+      APP_NAME: (process.env.APP_NAME as string) ?? "App",
+      APP_NAME_ROUTE: (process.env.APP_NAME_ROUTE as string) ?? "index",
+      S3_BUCKET_ENDPOINT: (process.env.S3_BUCKET_ENDPOINT as string) ?? "",
+      APP_MAIN: (process.env.APP_MAIN as string) ?? "",
+      APP_ACCOUNT: (process.env.APP_ACCOUNT as string) ?? "",
+      APP_ADMIN: (process.env.APP_ADMIN as string) ?? "",
+      APP_ORG: (process.env.APP_ORG as string) ?? "",
+      APP_AFFILIATE: (process.env.APP_AFFILIATE as string) ?? "",
+      APP_INVENTORY: (process.env.APP_INVENTORY as string) ?? "",
+      APP_ASSET: (process.env.APP_ASSET as string) ?? "",
+      APP_BOOK_KEEPING: (process.env.APP_BOOK_KEEPING as string) ?? "",
+    },
+  },
+
+  modules: [
+    (_options, nuxt) => {
+      nuxt.hooks.hook("vite:extendConfig", (config) => {
+        // @ts-expect-error
+        config.plugins.push(vuetify({ autoImport: true }));
+      });
+    },
+  ],
+
+  vite: {
+    vue: {
+      template: {
+        transformAssetUrls,
+      },
+    },
+  },
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@goweekdays/layer-common",
+  "license": "MIT",
+  "type": "module",
+  "version": "0.0.1",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "dev": "nuxi dev .playground",
+    "dev:prepare": "nuxt prepare .playground",
+    "build": "nuxt build .playground",
+    "generate": "nuxt generate .playground",
+    "preview": "nuxt preview .playground",
+    "release": "yarn run build && changeset publish"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.9",
+    "@nuxt/eslint": "latest",
+    "eslint": "^9.14.0",
+    "nuxt": "^3.13.2",
+    "typescript": "^5.6.3",
+    "vite-plugin-vuetify": "^2.0.4",
+    "vue": "latest",
+    "vuetify": "^3.7.3"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e",
+  "dependencies": {
+    "@mdi/font": "^7.4.47",
+    "sass": "^1.80.6"
+  }
+}

package/plugins/API.ts

@@ -0,0 +1,42 @@
+export default defineNuxtPlugin(() => {
+    const { cookieConfig } = useRuntimeConfig().public;
+
+    const api = $fetch.create({
+        baseURL: "/",
+        retry: 1,
+        retryStatusCodes: [401],
+        retryDelay: 500,
+        onRequest({ options }) {
+            const accessToken = useCookie("accessToken", cookieConfig).value;
+            options.headers = accessToken
+                ? { Authorization: `Bearer ${accessToken}` }
+                : {};
+        },
+
+        async onResponseError({ response }) {
+            if (response.status === 401) {
+                await $fetch("/api/auth/refresh", {
+                    baseURL: "/",
+                    method: "POST",
+                    server: false,
+                    credentials: "include",
+                    body: JSON.stringify({ token: useCookie("refreshToken", cookieConfig).value }),
+
+                    onResponse({ response }) {
+                        if (response.status === 200) {
+                            useCookie("accessToken", cookieConfig).value =
+                                response._data.token;
+                        }
+                    },
+                });
+            }
+        },
+    });
+
+    // Expose to useNuxtApp().$api
+    return {
+        provide: {
+            api,
+        },
+    };
+});

package/plugins/vuetify.ts

@@ -0,0 +1,44 @@
+// import this after install `@mdi/font` package
+import "@mdi/font/css/materialdesignicons.css";
+
+import "vuetify/styles";
+import { createVuetify } from "vuetify";
+import { VStepperVertical } from "vuetify/labs/VStepperVertical";
+
+const defaultTheme = {
+  dark: false,
+};
+
+export default defineNuxtPlugin((app) => {
+  const vuetify = createVuetify({
+    defaults: {
+      VTextField: {
+        variant: "outlined",
+        density: "comfortable",
+      },
+      VAutocomplete: {
+        variant: "outlined",
+        density: "comfortable",
+      },
+      VSelect: {
+        variant: "outlined",
+        density: "comfortable",
+      },
+      VTextarea: {
+        variant: "outlined",
+        density: "comfortable",
+      },
+    },
+    theme: {
+      defaultTheme: "defaultTheme",
+      themes: {
+        defaultTheme,
+      },
+    },
+    components: {
+      VStepperVertical,
+    },
+  });
+
+  app.vueApp.use(vuetify);
+});

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./.playground/.nuxt/tsconfig.json"
+}

package/types/address.d.ts

@@ -0,0 +1,13 @@
+declare type TAddress = {
+  _id?: string;
+  type: string;
+  user?: string;
+  org?: string;
+  country: string;
+  address: string;
+  continuedAddress?: string;
+  city: string;
+  province: string;
+  postalCode: string;
+  taxId: string;
+};

package/types/local.d.ts

@@ -0,0 +1,43 @@
+declare type TUser = {
+  _id: string;
+  email: string;
+  password: string;
+  firstName: string;
+  middleName?: string;
+  lastName: string;
+  suffix?: string;
+  birthMonth?: string;
+  birthDate?: string;
+  birthYear?: string;
+  profile?: string;
+  defaultOrg?: string;
+  createdAt: string;
+  updatedAt: string;
+  status: string;
+  deletedAt: string;
+};
+
+declare type TToken = {
+  accessToken: string;
+  refreshToken: string;
+  id: string;
+};
+
+declare type TNavigationRoute = {
+  name: string;
+  params?: TKeyValuePair;
+};
+
+declare type TNavigationItem = {
+  title: string;
+  icon?: string;
+  route?: TNavigationRoute;
+  children?: TNavigationItem[];
+};
+
+declare type TKeyValuePair<
+  K extends string | number | symbol = string,
+  V = string | number | object | Array | TKeyValuePair
+> = {
+  [key in K]: V;
+};

package/types/org.d.ts

@@ -0,0 +1,12 @@
+declare type TOrg = {
+  _id?: string;
+  name: string;
+  email: string;
+  contact: string;
+  busInst: string;
+  type: string;
+  createdAt?: string;
+  updatedAt?: string;
+  status?: string;
+  deletedAt?: string;
+};

package/types/permission.d.ts

@@ -0,0 +1,24 @@
+declare type TPermissionCheck =
+  | boolean
+  | ((user: TRole, data?: any) => boolean);
+
+declare type TPermission = {
+  check: TPermissionCheck;
+  description: string;
+};
+
+declare type TPermissions = {
+  [resource: string]: {
+    [action: string]: TPermission;
+  };
+};
+
+declare type TRole = {
+  _id?: string;
+  name: string;
+  description: string;
+  permissions: string[];
+  createdAt?: string;
+  updatedAt?: string;
+  deletedAt?: string;
+};

package/types/role.d.ts

@@ -0,0 +1,11 @@
+declare type TRole = {
+  _id?: string;
+  name?: string;
+  permissions?: Array<string>;
+  type?: string;
+  status?: string;
+  createdBy?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  deletedAt?: string;
+};

package/types/subscription.d.ts

@@ -0,0 +1,9 @@
+declare type TSubscription = {
+  _id?: ObjectId;
+  user: ObjectId | string;
+  subscriptionId: string;
+  status?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  deletedAt?: string;
+};