@goweekdays/layer-core 1.0.0

package/app/composables/useMember.ts

@@ -0,0 +1,100 @@
+export default function useMember() {
+  const members = useState<Array<TMember>>("members", () => []);
+  const page = useState("page", () => 1);
+  const pages = useState("pages", () => 0);
+  const pageRange = useState("pageRange", () => "-- - -- of --");
+
+  const member = useState<TMember>("member", () => ({
+    _id: "",
+    org: "",
+    orgName: "",
+    name: "",
+    user: "",
+    role: "",
+    roleName: "",
+    status: "",
+    createdAt: "",
+    updatedAt: "",
+    deletedAt: "",
+  }));
+
+  function getByUserId(user: string) {
+    return $fetch<TMember>(`/api/members/user/${user}`);
+  }
+
+  function getByUserType(user: string, type: string, org?: string) {
+    return $fetch<TMember>(`/api/members/user/${user}/app/${type}`, {
+      method: "GET",
+      query: { org },
+    });
+  }
+
+  async function getAll({
+    page = 1,
+    search = "",
+    limit = 10,
+    user = "",
+    org = "",
+    type = "",
+    status = "active",
+  } = {}) {
+    return $fetch<Record<string, any>>("/api/members", {
+      method: "GET",
+      query: { page, limit, search, user, org, type, status },
+    });
+  }
+
+  function createUserByVerification(
+    verificationId: string,
+    payload: Record<string, any>
+  ) {
+    return $fetch<Record<string, any>>(`/api/users/invite/${verificationId}`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  function createMemberInvite(verificatonId: string) {
+    return $fetch<TMember>(`/api/members/verification/${verificatonId}`, {
+      method: "POST",
+    });
+  }
+
+  function updateMemberStatus(id: string, status: string) {
+    return $fetch<Record<string, any>>(
+      `/api/members/status/${status}/id/${id}`,
+      {
+        method: "PUT",
+      }
+    );
+  }
+
+  function updateMemberRole(
+    id: string,
+    role: string,
+    type: string,
+    org: string
+  ) {
+    return $fetch<Record<string, any>>(
+      `/api/members/id/${id}/role/${role}/type/${type}/org/${org}`,
+      {
+        method: "PUT",
+      }
+    );
+  }
+  return {
+    members,
+    member,
+    page,
+    pages,
+    pageRange,
+
+    getAll,
+    getByUserId,
+    createUserByVerification,
+    createMemberInvite,
+    getByUserType,
+    updateMemberStatus,
+    updateMemberRole,
+  };
+}

package/app/composables/useRole.ts

@@ -0,0 +1,87 @@
+export default function useRole() {
+  function createRole(
+    { name, permissions, type, org } = {} as {
+      name: string;
+      permissions: Array<string>;
+      type: string;
+      org: string;
+    }
+  ) {
+    return $fetch("/api/roles", {
+      method: "POST",
+      body: { name, permissions, type, org },
+    });
+  }
+
+  function getRoles({
+    search = "",
+    page = 1,
+    limit = 20,
+    type = "",
+    org = "",
+  } = {}) {
+    return $fetch<Record<string, any>>("/api/roles", {
+      method: "GET",
+      query: { search, page, limit, type, org },
+    });
+  }
+
+  function getRoleById(id: string) {
+    return $fetch<Record<string, any>>(`/api/roles/id/${id}`, {
+      method: "GET",
+    });
+  }
+
+  function updateRoleById(
+    _id: string,
+    name?: string,
+    permissions?: Array<string>
+  ) {
+    return $fetch(`/api/roles/id/${_id}`, {
+      method: "PATCH",
+      body: { name, permissions },
+    });
+  }
+
+  function updatePermissionById(_id: string, permissions?: Array<string>) {
+    return $fetch(`/api/roles/permissions/id/${_id}`, {
+      method: "PATCH",
+      body: { permissions },
+    });
+  }
+
+  function updateRoleFieldById(_id: string, field: string, value: string) {
+    return $fetch(`/api/roles/${_id}`, {
+      method: "PATCH",
+      body: { field, value },
+    });
+  }
+
+  function deleteRole(_id: string) {
+    return $fetch<Record<string, any>>(`/api/roles/${_id}`, {
+      method: "DELETE",
+    });
+  }
+
+  const role = ref({
+    _id: "",
+    name: "",
+    org: "",
+    permissions: [],
+    createdAt: "",
+    updatedAt: "",
+    deletedAt: "",
+    default: false,
+  });
+
+  return {
+    role,
+    createRole,
+    getRoles,
+    getRoleById,
+    updateRoleById,
+    updateRoleFieldById,
+    deleteRole,
+    updatePermissionById,
+  };
+}

package/app/composables/useUtils.ts

@@ -0,0 +1,308 @@
+export default function useUtils() {
+  const requiredRule = (v: string) => !!v || "Required";
+
+  const emailRule = (v: string): true | string => {
+    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!v) return true;
+    return regex.test(v) || "Please enter a valid email address";
+  };
+
+  const validateDate = (value: string): boolean | string => {
+    const dateRegex = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$/;
+
+    if (!dateRegex.test(value)) return "Invalid date format (MM/DD/YYYY)";
+
+    return true;
+  };
+
+  function requireListRule(value: string[]) {
+    return value.length ? "" : "Required";
+  }
+
+  const minOneMonthAdvance = (value: string): boolean | string => {
+    if (!/^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$/.test(value)) {
+      return "Invalid date format (MM/DD/YYYY)";
+    }
+
+    const [month, day, year] = value.split("/").map(Number);
+    const selectedDate = new Date(year ?? 0, (month ?? 0) - 1, day);
+
+    const currentDate = new Date();
+    const minDate = new Date();
+    minDate.setMonth(currentDate.getMonth() + 1); // 1 month in advance
+
+    return (
+      selectedDate >= minDate || "Date must be at least 1 month in advance"
+    );
+  };
+
+  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 validateKey(value: string) {
+    const pattern = /^[a-z._-]+$/;
+    return (
+      pattern.test(value) || "Key must be lowercase and can include ., _, -"
+    );
+  }
+
+  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 words = name.trim().split(/\s+/); // Split by spaces
+
+    if (words.length === 1) {
+      return words[0]?.slice(0, 2).toUpperCase(); // Take first two letters of the single word
+    }
+
+    return words
+      .map((word) => word[0]?.toUpperCase()) // Take the first letter of each word and capitalize
+      .join("")
+      .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 $fetch<Array<Record<string, any>>>(
+        "https://restcountries.com/v3.1/all?fields=name,currencies,idd",
+        { method: "GET" }
+      );
+
+      const uniqueCountries: Map<
+        string,
+        { index: string; name: string; code: string }
+      > = 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,
+  });
+
+  function formatNumber(
+    amount: number,
+    options: {
+      currency?: string;
+      locale?: string;
+      useSymbol?: boolean;
+      decimalPlaces?: number;
+    } = {}
+  ): string {
+    const {
+      currency,
+      locale = "en-US",
+      useSymbol = false,
+      decimalPlaces = 2,
+    } = options;
+
+    return new Intl.NumberFormat(locale, {
+      style: useSymbol && currency ? "currency" : "decimal",
+      currency: currency || "USD", // Default currency (ignored if `useSymbol` is false)
+      minimumFractionDigits: decimalPlaces,
+      maximumFractionDigits: decimalPlaces,
+    }).format(amount);
+  }
+
+  // 🔹 Examples:
+  // console.log(formatNumber(1234.56)); // "1,234.56" (comma separator, 2 decimals)
+  // console.log(formatNumber(1234.56, { decimalPlaces: 0 })); // "1,234" (no decimals)
+  // console.log(formatNumber(1234.56, { useSymbol: true, currency: "USD" })); // "$1,234.56"
+  // console.log(formatNumber(1234.56, { useSymbol: true, currency: "PHP", decimalPlaces: 0 })); // "₱1,234"
+  // console.log(formatNumber(1234.56, { useSymbol: false, decimalPlaces: 0 })); // "1,234"
+  // console.log(formatNumber(1234.56, { useSymbol: true, currency: "EUR", locale: "de-DE" })); // "1.234,56 €"
+  // console.log(formatNumber(1234.56, { useSymbol: true, currency: "EUR", locale: "de-DE", decimalPlaces: 0 })); // "1.234 €"
+
+  function computeTieredCost(
+    seats: number,
+    tiers: { min: number; max: number; price: number }[],
+    remainingDays?: number,
+    totalDaysInMonth?: number
+  ) {
+    let totalCost = 0;
+
+    for (let i = 1; i <= seats; i++) {
+      for (const { min, max, price } of tiers) {
+        const effectiveMax = max === 0 ? Infinity : max;
+
+        if (i >= min && i <= effectiveMax) {
+          // Prorate the cost for this seat based on its tier price
+          if (remainingDays && totalDaysInMonth) {
+            totalCost += price * (remainingDays / totalDaysInMonth);
+            break;
+          }
+
+          totalCost += price;
+          break; // Stop checking once we apply the correct tier pricing
+        }
+      }
+    }
+
+    return totalCost; // This now returns the total prorated cost
+  }
+
+  function convertPermissionsToArray(permissions: TPermissions) {
+    return Object.entries(permissions).flatMap(([resource, actions]) =>
+      Object.keys(actions).map((action) => `${resource}:${action}`)
+    );
+  }
+
+  function extractMonthYear(expiry: string) {
+    const [month, year] = expiry.split("/");
+    return {
+      month: month?.padStart(2, "0"),
+      year: 2000 + parseInt(year ?? "", 10),
+    };
+  }
+
+  function getRouteParam(field = "") {
+    if (!field) return "";
+
+    return (useRoute().params[field] as string) ?? "";
+  }
+
+  function replaceMatch(str: string, match: string, replace: string) {
+    return str.replace(new RegExp(match, "g"), replace);
+  }
+
+  function setRouteParams(...args: Array<Record<string, string>>) {
+    const params: Record<string, string> = {};
+
+    args.forEach((arg) => {
+      Object.entries(arg).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== "") {
+          params[key] = value;
+        }
+      });
+    });
+
+    return params;
+  }
+
+  function positiveNumberRule(v: number) {
+    return (v && v >= 1) || "Value must be greater or equal to 1";
+  }
+
+  return {
+    requiredRule,
+    emailRule,
+    passwordRule,
+    confirmPasswordRule,
+    validateEmail,
+    validatePassword,
+    back,
+    debounce,
+    insertBetween,
+    getNameInitials,
+    getDimensions,
+    validateWord,
+    getCountries,
+    formatter,
+    formatNumber,
+    validateDate,
+    minOneMonthAdvance,
+    computeTieredCost,
+    requireListRule,
+    convertPermissionsToArray,
+    extractMonthYear,
+    getRouteParam,
+    replaceMatch,
+    setRouteParams,
+    positiveNumberRule,
+    validateKey,
+  };
+}

package/app/layouts/plain.vue

@@ -0,0 +1,7 @@
+<template>
+  <v-app>
+    <v-main>
+      <slot />
+    </v-main>
+  </v-app>
+</template>

package/app/middleware/01.auth.ts

@@ -0,0 +1,14 @@
+export default defineNuxtRouteMiddleware(async () => {
+  // Ensure middleware runs only on the client side
+  if (import.meta.server) return;
+
+  const { cookieConfig } = useLocalSetup();
+
+  // Get access token from cookies
+  const sid = useCookie("sid", cookieConfig).value;
+
+  if (!sid) {
+    // Redirect to login page if no access token
+    return navigateTo({ name: "index" });
+  }
+});

package/app/middleware/org.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+const hexSchema = z
+  .string()
+  .regex(/^[0-9a-fA-F]{24}$/, "Invalid organization ID");
+
+export default defineNuxtRouteMiddleware((to) => {
+  const org = (to.params.org as string) ?? "";
+
+  if (org && !hexSchema.safeParse(org).success) {
+    return navigateTo({ name: "require-organization" }, { replace: true });
+  }
+});

package/app/pages/forgot-password.vue

@@ -0,0 +1,76 @@
+<template>
+  <v-row no-gutters class="fill-height" justify="center" align-content="center">
+    <v-col cols="12" class="mb-6">
+      <v-row no-gutters justify="center">
+        <nuxt-link
+          class="text-h2 font-weight-bold text-decoration-none"
+          style="color: unset"
+          :to="{ name: 'index' }"
+        >
+          GoWeekdays
+        </nuxt-link>
+      </v-row>
+    </v-col>
+
+    <v-col cols="12" lg="3" md="4" sm="6">
+      <v-form v-model="isValid" @submit.prevent="submit(email)">
+        <v-row no-gutters>
+          <v-col cols="12">
+            <v-row no-gutters>
+              <v-col cols="12" class="text-h6 font-weight-bold"> Email </v-col>
+              <v-col cols="12">
+                <v-text-field
+                  v-model="email"
+                  :rules="[requiredRule, emailRule]"
+                ></v-text-field>
+              </v-col>
+            </v-row>
+          </v-col>
+
+          <v-col v-if="message" cols="12" class="my-2 text-center font-italic">
+            {{ message }}
+          </v-col>
+
+          <v-col cols="12">
+            <v-row no-gutters justify="center">
+              <v-btn
+                type="submit"
+                variant="tonal"
+                :disabled="!isValid"
+                rounded="xl"
+                size="large"
+              >
+                submit
+              </v-btn>
+            </v-row>
+          </v-col>
+
+          <v-col cols="12" class="mt-2 text-center">
+            All good? <nuxt-link :to="{ name: 'login' }">Login</nuxt-link>
+          </v-col>
+        </v-row>
+      </v-form>
+    </v-col>
+  </v-row>
+</template>
+
+<script setup lang="ts">
+definePageMeta({
+  layout: "plain",
+});
+const { requiredRule, emailRule } = useUtils();
+const email = ref("");
+const isValid = ref(false);
+
+const { forgotPassword } = useLocalAuth();
+const message = ref("");
+
+async function submit(email = "") {
+  try {
+    const result: any = await forgotPassword(email);
+    message.value = result.message;
+  } catch (error: any) {
+    message.value = error.message;
+  }
+}
+</script>

package/app/pages/index.vue

@@ -0,0 +1,3 @@
+<template>
+  <h1>Index</h1>
+</template>