@devcoffee/nuxt-core 1.0.1 → 1.1.0

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

@@ -0,0 +1,111 @@
+import { useRequestURL } from "#app";
+import {
+  computed,
+  createError,
+  navigateTo,
+  ref,
+  useLogger,
+  useNuxtApp,
+  useRequestFetch,
+  useSessionContext
+} from "#imports";
+export function useAuthContext(initiator) {
+  const { callHook, runWithContext } = useNuxtApp();
+  const { getValue } = useSessionContext();
+  const fetchRequest = useRequestFetch();
+  const logger = useLogger({ level: 2, tag: "authContext" });
+  const processing = ref(false);
+  const session = computed(() => getValue(initiator, "useAuthContext.session"));
+  const isAuthenticated = computed(() => {
+    const { isAuthenticated: isAuthenticated2 = false } = session.value || {};
+    return isAuthenticated2;
+  });
+  const user = computed(() => session.value.user);
+  function sanitizeError(err) {
+    if (err?.statusCode) {
+      return createError(err);
+    } else if (err instanceof TypeError || err instanceof SyntaxError) {
+      return createError({
+        error: true,
+        statusCode: 400,
+        statusMessage: "Server Error",
+        message: err.message,
+        stack: err.stack,
+        cause: err,
+        fatal: true
+      });
+    } else {
+      return createError({
+        error: true,
+        statusCode: 500,
+        statusMessage: "Server Error",
+        message: String(err),
+        cause: err,
+        fatal: true
+      });
+    }
+  }
+  async function login(redirectTo) {
+    if (isAuthenticated.value) {
+      return;
+    }
+    const endpoint = new URL("/api/_auth/authorize-url", useRequestURL());
+    if (redirectTo) {
+      endpoint.searchParams.set("redirectUrl", redirectTo);
+    }
+    await fetchRequest(endpoint.toString(), {
+      onRequest() {
+        processing.value = true;
+      }
+    }).then(
+      async ({ redirectUrl }) => runWithContext(async () => await navigateTo(redirectUrl, { external: true, replace: true }))
+    ).catch((ex) => {
+      logger.log(`[login] failed error:${ex}`, ex);
+      throw sanitizeError(ex);
+    }).finally(() => processing.value = false);
+  }
+  async function authorize(parameters) {
+    const endpoint = new URL("/api/_auth/token", useRequestURL());
+    await fetchRequest(endpoint.toString(), {
+      method: "POST",
+      body: parameters,
+      onRequest() {
+        processing.value = true;
+      }
+    }).then(async (response) => {
+      await runWithContext(async () => await callHook("user:loggedIn"));
+      return response;
+    }).then(
+      async ({ redirectUrl }) => runWithContext(async () => await navigateTo(redirectUrl))
+    ).catch((ex) => {
+      logger.log(`[authorize] failed error:${ex}`, ex);
+      throw sanitizeError(ex);
+    }).finally(() => processing.value = false);
+  }
+  async function logout() {
+    const endpoint = new URL("/api/_auth/logout", useRequestURL());
+    await fetchRequest(endpoint.toString(), {
+      method: "POST",
+      onRequest() {
+        processing.value = true;
+      }
+    }).then(async (response) => {
+      await runWithContext(async () => await callHook("user:loggedOut"));
+      return response;
+    }).then(
+      async ({ redirectUrl }) => runWithContext(async () => await navigateTo(redirectUrl))
+    ).catch((ex) => {
+      logger.log(`[logout] failed error:${ex}`, ex);
+      throw sanitizeError(ex);
+    }).finally(() => processing.value = false);
+  }
+  return {
+    user,
+    session,
+    processing,
+    isAuthenticated,
+    login,
+    authorize,
+    logout
+  };
+}

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

@@ -1,5 +1,5 @@
-import type { LogLevel } from 'consola';
+import type { CoreLogInstance, CoreLogLevel } from '#app';
 export default function useLogger(opts?: {
     tag?: string;
-    level?: LogLevel;
-}): any;
+    level?: CoreLogLevel;
+}): CoreLogInstance;

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

@@ -0,0 +1,22 @@
+/**
+ * 🔐 Provides access to the global session context plugin.
+ *
+ * This composable is a lightweight wrapper around the `$sessionContext`
+ * provided by the Nuxt plugin, allowing components and composables to
+ * easily access session-related utilities such as `getValue()` and `refetch()`.
+ *
+ * @example
+ * ```ts
+ * const { getValue, refetch } = useSessionContext()
+ * const session = getValue()
+ *
+ * if (session.isAuthenticated) {
+ *   console.log('User:', session.user)
+ * }
+ * ```
+ *
+ * @returns {import('#app').NuxtApp['$sessionContext']} The session context plugin instance.
+ *
+ * @since 1.0.0
+ */
+export declare function useSessionContext(): import('#app').NuxtApp['$sessionContext'];

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

@@ -0,0 +1,5 @@
+import { useNuxtApp } from "#app";
+export function useSessionContext() {
+  const { $sessionContext } = useNuxtApp();
+  return $sessionContext;
+}

package/dist/runtime/app/middleware/authts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Nuxt route middleware handling authentication and access control.
+ *
+ * Handles all major auth scenarios:
+ *  - Redirects unauthenticated users from protected routes to login.
+ *  - Redirects authenticated users away from login/register pages.
+ *  - Stores intended redirect URL in cookie before login.
+ *
+ * @since 1.0.0
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/app/middleware/authts.js

@@ -0,0 +1,101 @@
+import {
+  abortNavigation,
+  createError,
+  defineNuxtRouteMiddleware,
+  navigateTo,
+  refreshNuxtData,
+  useCookie,
+  useNuxtApp,
+  useRequestEvent,
+  useRuntimeConfig
+} from "#app";
+import { omit } from "#devcoffee-core/utils";
+import { useAuthContext, useLogger } from "#imports";
+import { getCookie, setCookie } from "h3";
+function normalizedAuthMeta(normalizedPath, routeMeta, opts) {
+  const authts = routeMeta.authts || {};
+  const { openIdRedirectUri } = opts;
+  const normalizedRedirectUri = (openIdRedirectUri.split("?")[0] ?? "").replace(/\/$/, "");
+  const normalizedCurrentPath = normalizedPath.replace(/\/$/, "");
+  const unauthenticatedOnly = authts.unauthenticatedOnly ?? [normalizedRedirectUri].includes(normalizedCurrentPath);
+  return {
+    // A page with unauthenticatedOnly: true is by definition not a protected route.
+    // Default required to false when unauthenticatedOnly is true to avoid contradictory meta.
+    required: authts.required ?? (unauthenticatedOnly ? false : ![normalizedRedirectUri].includes(normalizedCurrentPath)),
+    unauthenticatedOnly,
+    roles: []
+  };
+}
+function setRedirectCookie(name, redirectUrl) {
+  if (import.meta.server) {
+    const event = useRequestEvent();
+    if (event) {
+      const { cookieOpts } = useRuntimeConfig(event).nuxtCore.authts.sessions;
+      setCookie(event, name, redirectUrl, omit(cookieOpts, ["expires", "maxAge"]));
+    }
+  }
+  if (import.meta.client) {
+    const cookie = useCookie(name);
+    cookie.value = redirectUrl;
+  }
+}
+function getRedirectCookie(name) {
+  if (import.meta.server) {
+    const event = useRequestEvent();
+    if (event) {
+      return getCookie(event, name);
+    }
+  }
+  if (import.meta.client) {
+    return useCookie(name).value || void 0;
+  }
+}
+export default defineNuxtRouteMiddleware(async (to) => {
+  const nuxtApp = useNuxtApp();
+  await nuxtApp.$sessionReady;
+  const logger = useLogger({ tag: "authts.middleware", level: 3 });
+  const {
+    loginUri,
+    defaultLoginRedirectUri,
+    redirectUri,
+    redirectCookie,
+    ignoreRegexPatterns,
+    ignoreRegexPatternsDev
+  } = useRuntimeConfig().public.nuxtCore.authts;
+  const normalizedPath = to.path.toLowerCase();
+  const authMeta = normalizedAuthMeta(normalizedPath, to.meta, { openIdRedirectUri: redirectUri.toLowerCase() });
+  if (ignoreRegexPatterns.length && ignoreRegexPatterns.some((pattern) => pattern.test(normalizedPath))) {
+    logger.debug(`Bypassing auth checks for ignored path: ${normalizedPath}`);
+    return;
+  }
+  if (import.meta.env.DEV && ignoreRegexPatternsDev.length && ignoreRegexPatternsDev.some((pattern) => pattern.test(normalizedPath))) {
+    logger.debug(`Bypassing auth checks for ignored path (dev): ${normalizedPath}`);
+    return;
+  }
+  if (authMeta.required && authMeta.unauthenticatedOnly) {
+    return abortNavigation(
+      createError({
+        statusCode: 500,
+        fatal: true,
+        statusMessage: "Invalid route meta",
+        message: 'A route cannot be both "required" and "unauthenticatedOnly".'
+      })
+    );
+  }
+  if (import.meta.client) {
+    await refreshNuxtData("authts:session");
+  }
+  const { isAuthenticated } = useAuthContext("core.app.authts.middleware");
+  const loginPath = loginUri.toLowerCase();
+  const loggedInRedirect = getRedirectCookie(redirectCookie) || defaultLoginRedirectUri;
+  if (isAuthenticated.value && normalizedPath === loginPath) {
+    return navigateTo(loggedInRedirect, { replace: true });
+  }
+  if (isAuthenticated.value && authMeta.unauthenticatedOnly && normalizedPath !== loginPath) {
+    return abortNavigation(createError({ statusCode: 404, message: "Page not found." }));
+  }
+  if (!isAuthenticated.value && authMeta.required && normalizedPath !== loginPath) {
+    setRedirectCookie(redirectCookie, to.fullPath);
+    return navigateTo(loginUri, { replace: true });
+  }
+});

package/dist/runtime/app/pages/authorize.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/pages/authorize.vue

@@ -0,0 +1,32 @@
+<script setup>
+import { computed, onMounted } from "vue";
+import { createError, useRoute } from "#app";
+import { useAuthContext } from "#imports";
+const { query } = useRoute();
+const { authorize } = useAuthContext("core.app.pages.authorize");
+const searchParms = computed(() => {
+  const params = new URLSearchParams();
+  if (query.code) {
+    params.set("code", query.code);
+  }
+  if (query.state) {
+    params.set("state", query.state);
+  }
+  return params;
+});
+if (!searchParms.value.has("code")) {
+  throw createError({
+    status: 400,
+    message: "Invalid code params"
+  });
+}
+onMounted(async () => {
+  if (searchParms.value.has("code")) {
+    await authorize(searchParms.value);
+  }
+});
+</script>
+
+<template>
+  <div>Nuxt module auth callback!</div>
+</template>

package/dist/runtime/app/pages/authorize.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/plugins/authts.d.ts

@@ -0,0 +1,82 @@
+import type { NuxtSessionContext } from '#app';
+/**
+ * Type definition for the session context plugin.
+ *
+ * Provides helper methods to get and refresh the current session.
+ *
+ * @since 1.0.0
+ */
+export type SessionContextPlugin = {
+    /**
+     * Refetches the session context from the server and updates the local state.
+     * @since 1.0.0
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Returns the current session context value.
+     * Throws if the context has not yet been initialized.
+     * @param {...string|undefined} initiators - Optional initiators for logging purposes.
+     * @since 1.0.0
+     */
+    getValue: (...initiators: (string | undefined)[]) => NuxtSessionContext;
+};
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        /**
+         * Provides access to session state and helper methods in Vue components.
+         * @since 1.0.0
+         */
+        $sessionContext: SessionContextPlugin;
+    }
+}
+declare module '#app' {
+    interface NuxtApp {
+        /**
+         * Provides access to session-related state and actions.
+         * @since 1.0.0
+         */
+        $sessionContext: SessionContextPlugin;
+        /**
+         * Promise that resolves when the initial session fetch completes.
+         * Awaited by route middleware to prevent reading auth state before session is ready.
+         * Pre-resolved on SSR (plugin completes before middleware runs).
+         * @since 1.0.0
+         */
+        $sessionReady: Promise<void>;
+    }
+    interface RuntimeNuxtHooks {
+        /**
+         * Hook triggered to fetch the latest session data from the server.
+         * Can be manually called when authentication state changes.
+         * @since 1.0.0
+         */
+        'session:fetch': (initiator?: string) => Promise<void>;
+        /**
+         * Hook triggered after session `session:fetch`.
+         * @since 1.0.0
+         */
+        'session:changed': (data: NuxtSessionContext) => Awaitable<void>;
+        /**
+         * Hook triggered after a successful user login.
+         * Used to re-sync session state or perform follow-up logic.
+         * @since 1.0.0
+         */
+        'user:loggedIn': () => Promise<void>;
+        /**
+         * Hook triggered after a successful user logout.
+         * Used to re-sync session state or perform follow-up logic.
+         * @since 1.0.0
+         */
+        'user:loggedOut': () => Promise<void>;
+    }
+}
+/**
+ * 🧩 Nuxt plugin for managing user session state.
+ *
+ * This plugin initializes and maintains the authenticated user session context.
+ * It exposes helper methods and hooks for session refetching and user login events.
+ *
+ * @since 1.0.0
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/app/plugins/authts.js

@@ -0,0 +1,91 @@
+import { watch } from "vue";
+import {
+  createError,
+  defineNuxtPlugin,
+  refreshNuxtData,
+  useAsyncData,
+  useCookie,
+  useNuxtApp,
+  useRequestFetch,
+  useRuntimeConfig,
+  useState
+} from "#app";
+export default defineNuxtPlugin(async (_nuxtApp) => {
+  const fetchRequest = useRequestFetch();
+  const logger = useNuxtApp().$logging.getLogger({ tag: "nuxt-session", level: 3 });
+  const context = useState("sessionContext", () => null);
+  watch(
+    () => context.value,
+    (value) => {
+      _nuxtApp.callHook("session:changed", value);
+    }
+  );
+  async function __getServerSession(initiator) {
+    try {
+      logger.debug(`[__getServerSession] Called with initiator: '${initiator}'`);
+      return await fetchRequest("/api/_auth/session");
+    } catch (ex) {
+      throw createError({
+        status: 500,
+        fatal: true,
+        statusMessage: "Failed to fetch session",
+        message: ex instanceof Error ? ex.message : String(ex),
+        cause: ex
+      });
+    }
+  }
+  let resolveReady;
+  const sessionReady = new Promise((r) => {
+    resolveReady = r;
+  });
+  _nuxtApp.provide("sessionReady", sessionReady);
+  const sessionId = useCookie(useRuntimeConfig().public.nuxtCore.authts.sessionCookie);
+  logger.debug(`Initial session fetch on plugin init with sessionId: ${sessionId.value}`);
+  if (sessionId.value) {
+    const { data } = await useAsyncData("authts:session", () => __getServerSession("plugin initialization"));
+    if (data.value) {
+      context.value = data.value;
+    }
+    watch(data, (newData) => {
+      if (newData) context.value = newData;
+    });
+  } else {
+    context.value = {
+      id: "",
+      isAuthenticated: false,
+      user: {
+        id: "",
+        sub: "",
+        email: "",
+        firstName: "Anonymous",
+        lastName: "User",
+        locale: "",
+        language: "",
+        timezone: ""
+      },
+      data: {}
+    };
+  }
+  resolveReady();
+  _nuxtApp.hooks.addHooks({
+    // session:fetch calls refreshNuxtData to stay coherent with useAsyncData cache (D-04)
+    "session:fetch": async (_initiator) => {
+      await refreshNuxtData("authts:session");
+    },
+    "user:loggedIn": async () => {
+      await _nuxtApp.callHook("session:fetch", "user:loggedIn");
+    },
+    "user:loggedOut": async () => {
+      await _nuxtApp.callHook("session:fetch", "user:loggedOut");
+    }
+  });
+  function getValue(...initiators) {
+    const initiator = initiators.map((s) => s || "?").join(" \u2192 ");
+    logger.debug(`Called getValue with initiator: '${initiator}'`);
+    return context.value;
+  }
+  async function refetch() {
+    await _nuxtApp.callHook("session:fetch");
+  }
+  _nuxtApp.provide("sessionContext", { getValue, refetch });
+});

package/dist/runtime/app/plugins/formatters.d.ts

@@ -0,0 +1,29 @@
+type PadOptions = {
+    prefix: string & {
+        __uppercaseBrand?: never;
+    };
+    separator: string;
+    length: number;
+    padChar: string;
+};
+type ToPad = (num: number, opts?: Partial<PadOptions>) => string;
+type AsPhoneText = (numStr: string) => string;
+type AsDateString = (date: Date) => string;
+type AsTimeString = (date: Date, seconds?: boolean) => string;
+type AsDateTimeString = (date: Date, seconds?: boolean) => string;
+type AsRelativeTimeString = (date: Date) => string;
+type PluginProviders = {
+    toPad: ToPad;
+    asPhoneText: AsPhoneText;
+    asDateString: AsDateString;
+    asTimeString: AsTimeString;
+    asDateTimeString: AsDateTimeString;
+    asRelativeTimeString: AsRelativeTimeString;
+};
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        $formatters: PluginProviders;
+    }
+}
+declare const _default: any;
+export default _default;

package/dist/runtime/app/plugins/formatters.js

@@ -0,0 +1,101 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { ref, useLogger } from "#imports";
+export default defineNuxtPlugin((_nuxtApp) => {
+  const logger = useLogger({ tag: "formatters", level: 3 });
+  const { defaultLocale, defaultLanguage, defaultTimeZone } = useRuntimeConfig().public.nuxtCore;
+  const currentLocale = ref(defaultLocale);
+  const currentLanguage = ref(defaultLanguage);
+  const currentTimeZone = ref(defaultTimeZone);
+  _nuxtApp.hooks.addHooks({
+    "dfLocale:changed": (value) => {
+      const { locale = defaultLocale, timeZone = defaultTimeZone, language = defaultLanguage } = value;
+      currentLocale.value = locale;
+      currentLanguage.value = language;
+      currentTimeZone.value = timeZone;
+      logger.debug(`dfLocale changed, updating locale='${locale}', language='${language}' and timezone='${timeZone}'.`);
+    }
+  });
+  function toPad(num, opts) {
+    const defaultOpts = {
+      prefix: "",
+      separator: "-",
+      length: 5,
+      padChar: "0",
+      ...opts
+    };
+    const parts = [String(num).padStart(defaultOpts.length, defaultOpts.padChar)];
+    if (defaultOpts.prefix) {
+      parts.push(defaultOpts.prefix);
+    }
+    return parts.reverse().join(defaultOpts.separator);
+  }
+  function asPhoneText(numStr) {
+    const digits = numStr.replace(/\D/g, "");
+    return digits.replace(/(\d{3})(\d{3})(\d{4})/, "($1) $2-$3");
+  }
+  function asDateString(date) {
+    logger.debug(`Format date with  locale ='${currentLocale.value}'`);
+    return new Intl.DateTimeFormat(currentLocale.value).format(date);
+  }
+  function asTimeString(date, seconds) {
+    const opts = {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+      timeZone: currentTimeZone.value
+    };
+    if (seconds) {
+      opts.second = "2-digit";
+    }
+    logger.debug(`Format time with options = '%o', locale ='${currentLocale.value}'`, opts);
+    return new Intl.DateTimeFormat(currentLocale.value, opts).format(date);
+  }
+  function asDateTimeString(date, seconds) {
+    const opts = {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+      timeZone: currentTimeZone.value
+    };
+    if (seconds) {
+      opts.second = "2-digit";
+    }
+    logger.debug(`Format datetime with options = '%o', locale ='${currentLocale.value}'`, opts);
+    return new Intl.DateTimeFormat(currentLocale.value, opts).format(date).replace(",", "");
+  }
+  function asRelativeTimeString(date) {
+    const opts = {
+      numeric: "auto",
+      style: "long"
+    };
+    logger.debug(`Format datetime with options = '%o', language ='${currentLanguage.value}'`, opts);
+    const rtf = new Intl.RelativeTimeFormat(currentLanguage.value, opts);
+    const diff = date.valueOf() - Date.now();
+    const units = {
+      year: 1e3 * 60 * 60 * 24 * 365,
+      month: 1e3 * 60 * 60 * 24 * 30,
+      day: 1e3 * 60 * 60 * 24,
+      hour: 1e3 * 60 * 60,
+      minute: 1e3 * 60,
+      second: 1e3
+    };
+    for (const [unit, ms] of Object.entries(units)) {
+      const value = Math.round(diff / ms);
+      if (Math.abs(value) >= 1) {
+        return rtf.format(value, unit);
+      }
+    }
+    return asDateTimeString(date, true);
+  }
+  _nuxtApp.provide("formatters", {
+    toPad,
+    asPhoneText,
+    asDateString,
+    asTimeString,
+    asDateTimeString,
+    asRelativeTimeString
+  });
+});

package/dist/runtime/app/plugins/locale.d.ts

@@ -0,0 +1,37 @@
+type LocaleState = {
+    locale: string;
+    language: string;
+    timeZone: string;
+};
+type LocaleProvider = LocaleState;
+/**
+ * 🧩 Nuxt plugin for locale utilities.
+ * @since 1.0.0
+ */
+declare const _default: any;
+export default _default;
+declare module 'vue' {
+    /**
+     * Provides access to locale utilities.
+     * @since 1.0.0
+     */
+    interface ComponentCustomProperties {
+        $dfLocale: LocaleProvider;
+    }
+}
+declare module '#app' {
+    interface NuxtApp {
+        /**
+         * Provides access to locale utilities.
+         * @since 1.0.0
+         */
+        $dfLocale: LocaleProvider;
+    }
+    interface RuntimeNuxtHooks {
+        /**
+         * Hook triggered after locale changed.
+         * @since 1.0.0
+         */
+        'dfLocale:changed': (value: LocaleState) => Awaitable<void>;
+    }
+}