@authup/client-web-nuxt 1.0.0-beta.20

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.mts

@@ -0,0 +1,23 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+type AuthupRuntimeOptions = {
+    apiURL?: string;
+    apiURLRuntimeKey?: string;
+    /**
+     * Separate apiURL for server side rendering.
+     */
+    apiURLServer?: string;
+    /**
+     * Separate extraction of apiURL for server side rendering.
+     */
+    apiURLServerRuntimeKey?: string;
+    cookieDomain?: string;
+    cookieDomainRuntimeKey?: string;
+    homeRoute?: string;
+    loginRoute?: string;
+    logoutRoute?: string;
+};
+
+declare const _default: _nuxt_schema.NuxtModule<AuthupRuntimeOptions, AuthupRuntimeOptions, false>;
+
+export { _default as default };

package/dist/module.d.ts

@@ -0,0 +1,23 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+type AuthupRuntimeOptions = {
+    apiURL?: string;
+    apiURLRuntimeKey?: string;
+    /**
+     * Separate apiURL for server side rendering.
+     */
+    apiURLServer?: string;
+    /**
+     * Separate extraction of apiURL for server side rendering.
+     */
+    apiURLServerRuntimeKey?: string;
+    cookieDomain?: string;
+    cookieDomainRuntimeKey?: string;
+    homeRoute?: string;
+    loginRoute?: string;
+    logoutRoute?: string;
+};
+
+declare const _default: _nuxt_schema.NuxtModule<AuthupRuntimeOptions, AuthupRuntimeOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@authup/client-web-nuxt",
+  "configKey": "authup",
+  "version": "1.0.0-beta.20",
+  "builder": {
+    "@nuxt/module-builder": "0.8.4",
+    "unbuild": "2.0.0"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,45 @@
+import { defineNuxtModule, addPlugin, addRouteMiddleware } from '@nuxt/kit';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { merge } from 'smob';
+
+const module = defineNuxtModule({
+  meta: {
+    name: "@authup/client-web-nuxt",
+    configKey: "authup"
+  },
+  defaults: {},
+  async setup(options, nuxt) {
+    const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
+    nuxt.options.build.transpile.push(runtimeDir);
+    const runtimeOptions = {
+      apiURL: options.apiURL,
+      apiURLRuntimeKey: options.apiURLRuntimeKey,
+      apiURLServer: options.apiURLServer,
+      apiURLServerRuntimeKey: options.apiURLServerRuntimeKey,
+      cookieDomain: options.cookieDomain,
+      cookieDomainRuntimeKey: options.cookieDomainRuntimeKey,
+      homeRoute: options.homeRoute,
+      loginRoute: options.loginRoute,
+      logoutRoute: options.logoutRoute
+    };
+    nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
+    if (nuxt.options.runtimeConfig.public.authup) {
+      nuxt.options.runtimeConfig.public.authup = merge(
+        nuxt.options.runtimeConfig.public.authup,
+        runtimeOptions
+      );
+    } else {
+      nuxt.options.runtimeConfig.public.authup = runtimeOptions;
+    }
+    addPlugin(path.resolve(runtimeDir, "plugins/00.pinia"));
+    addPlugin(path.resolve(runtimeDir, "plugins/01.kit"));
+    addRouteMiddleware({
+      name: "loggedIn",
+      path: path.resolve(runtimeDir, "middleware/00.session"),
+      global: true
+    });
+  }
+});
+
+export { module as default };

package/dist/runtime/constants.d.ts

@@ -0,0 +1,5 @@
+export declare enum RouteMetaKey {
+    REQUIRED_LOGGED_IN = "requireLoggedIn",
+    REQUIRED_LOGGED_OUT = "requireLoggedOut",
+    REQUIRED_PERMISSIONS = "requirePermissions"
+}

package/dist/runtime/constants.js

@@ -0,0 +1,6 @@
+export var RouteMetaKey = /* @__PURE__ */ ((RouteMetaKey2) => {
+  RouteMetaKey2["REQUIRED_LOGGED_IN"] = "requireLoggedIn";
+  RouteMetaKey2["REQUIRED_LOGGED_OUT"] = "requireLoggedOut";
+  RouteMetaKey2["REQUIRED_PERMISSIONS"] = "requirePermissions";
+  return RouteMetaKey2;
+})(RouteMetaKey || {});

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

@@ -0,0 +1,2 @@
+export * from './route-path.js';
+export * from './route-permissions.js';

package/dist/runtime/helpers/index.js

@@ -0,0 +1,2 @@
+export * from "./route-path.js";
+export * from "./route-permissions.js";

package/dist/runtime/helpers/route-path.d.ts

@@ -0,0 +1,7 @@
+import type { RouteLocationNormalized } from 'vue-router';
+type RoutePathBuildOptions = {
+    location?: RouteLocationNormalized;
+    excluded?: string[];
+};
+export declare function buildRoutePath(context?: RoutePathBuildOptions): string | undefined;
+export {};

package/dist/runtime/helpers/route-path.js

@@ -0,0 +1,13 @@
+export function buildRoutePath(context = {}) {
+  if (!context.location || context.location.query.redirect) {
+    return void 0;
+  }
+  if (context.excluded) {
+    for (let i = 0; i < context.excluded.length; i++) {
+      if (context.location.fullPath.startsWith(context.excluded[i])) {
+        return void 0;
+      }
+    }
+  }
+  return context.location.fullPath;
+}

package/dist/runtime/helpers/route-permissions.d.ts

@@ -0,0 +1,8 @@
+import { type Store } from '@authup/client-web-kit';
+import type { RouteLocationNormalized } from 'vue-router';
+type RoutePermissionsCheckOptions = {
+    routeLocation: RouteLocationNormalized;
+    store: Store;
+};
+export declare function checkRoutePermissions(context: RoutePermissionsCheckOptions): Promise<boolean>;
+export {};

package/dist/runtime/helpers/route-permissions.js

@@ -0,0 +1,41 @@
+import { storeToRefs } from "@authup/client-web-kit";
+import { hasOwnProperty } from "@authup/kit";
+import { RouteMetaKey } from "../constants.js";
+export async function checkRoutePermissions(context) {
+  const storeRefs = storeToRefs(context.store);
+  let identity;
+  if (storeRefs.userId.value) {
+    identity = {
+      type: "user",
+      id: storeRefs.userId.value
+    };
+  }
+  for (let i = 0; i < context.routeLocation.matched.length; i++) {
+    const match = context.routeLocation.matched[i];
+    if (!match.meta || !hasOwnProperty(match.meta, RouteMetaKey.REQUIRED_PERMISSIONS)) {
+      continue;
+    }
+    let permissions = [];
+    if (match.meta[RouteMetaKey.REQUIRED_PERMISSIONS]) {
+      if (Array.isArray(match.meta[RouteMetaKey.REQUIRED_PERMISSIONS])) {
+        permissions = match.meta[RouteMetaKey.REQUIRED_PERMISSIONS];
+      } else if (typeof match.meta[RouteMetaKey.REQUIRED_PERMISSIONS] === "string") {
+        permissions = [match.meta[RouteMetaKey.REQUIRED_PERMISSIONS]];
+      }
+    }
+    if (permissions.length === 0) {
+      continue;
+    }
+    try {
+      await context.store.permissionChecker.preCheckOneOf({
+        name: permissions,
+        data: {
+          identity
+        }
+      });
+    } catch (e) {
+      return false;
+    }
+  }
+  return true;
+}

package/dist/runtime/middleware/00.session.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").RouteMiddleware;
+export default _default;

package/dist/runtime/middleware/00.session.js

@@ -0,0 +1,78 @@
+import { storeToRefs, useStore } from "@authup/client-web-kit";
+import { defineNuxtRouteMiddleware, navigateTo, useRuntimeConfig } from "#imports";
+import { RouteMetaKey } from "../constants.js";
+import { buildRoutePath, checkRoutePermissions } from "../helpers/index.js";
+export default defineNuxtRouteMiddleware(
+  async (to, from) => {
+    const store = useStore();
+    const storeRefs = storeToRefs(store);
+    const runtimeConfig = useRuntimeConfig();
+    const runtimeOptions = runtimeConfig.public.authup;
+    const homeRoute = runtimeOptions.homeRoute || "/";
+    const loginRoute = runtimeOptions.loginRoute || "/login";
+    const logoutRoute = runtimeOptions.logoutRoute || "/logout";
+    try {
+      await store.resolve();
+    } catch (e) {
+      store.logout();
+      const redirect = buildRoutePath({
+        location: to,
+        excluded: [
+          logoutRoute,
+          loginRoute
+        ]
+      });
+      if (redirect) {
+        return navigateTo({
+          path: loginRoute,
+          query: {
+            redirect
+          }
+        });
+      }
+      return void 0;
+    }
+    const hasLoggedInProtection = to.matched.some(
+      (matched) => !!matched.meta[RouteMetaKey.REQUIRED_LOGGED_IN]
+    );
+    if (hasLoggedInProtection && !storeRefs.loggedIn.value) {
+      const redirect = buildRoutePath({
+        location: to,
+        excluded: [
+          logoutRoute,
+          loginRoute
+        ]
+      });
+      return navigateTo({
+        path: loginRoute,
+        query: {
+          ...redirect ? { redirect } : {}
+        }
+      });
+    }
+    const hasPermissionProtection = to.matched.some(
+      (matched) => !!matched.meta[RouteMetaKey.REQUIRED_PERMISSIONS]
+    );
+    if (hasPermissionProtection) {
+      const hasPermissions = await checkRoutePermissions({
+        store,
+        routeLocation: to
+      });
+      if (!hasPermissions) {
+        return navigateTo({
+          path: from ? from.fullPath : homeRoute
+        });
+      }
+    }
+    const hasLoggedOutProtection = to.matched.some(
+      (matched) => matched.meta[RouteMetaKey.REQUIRED_LOGGED_OUT]
+    );
+    if (hasLoggedOutProtection && storeRefs.loggedIn.value) {
+      store.logout();
+      return navigateTo({
+        path: to.fullPath
+      });
+    }
+    return void 0;
+  }
+);

package/dist/runtime/plugins/00.pinia.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("nuxt/app").Plugin<{
+    pinia: import("pinia").Pinia;
+}> & import("nuxt/app").ObjectPlugin<{
+    pinia: import("pinia").Pinia;
+}>;
+export default _default;

package/dist/runtime/plugins/00.pinia.js

@@ -0,0 +1,24 @@
+import { createPinia, setActivePinia } from "pinia";
+import { defineNuxtPlugin } from "#imports";
+export default defineNuxtPlugin({
+  name: "authupPinia",
+  enforce: "pre",
+  async setup(nuxt) {
+    if (nuxt.$pinia) {
+      return {};
+    }
+    const pinia = createPinia();
+    nuxt.vueApp.use(pinia);
+    setActivePinia(pinia);
+    if (import.meta.server) {
+      nuxt.payload.pinia = pinia.state.value;
+    } else if (nuxt.payload && nuxt.payload.pinia) {
+      pinia.state.value = nuxt.payload.pinia;
+    }
+    return {
+      provide: {
+        pinia
+      }
+    };
+  }
+});

package/dist/runtime/plugins/01.kit.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/01.kit.js

@@ -0,0 +1,90 @@
+import { install } from "@authup/client-web-kit";
+import { getPathValue } from "pathtrace";
+import {
+  defineNuxtPlugin,
+  tryUseNuxtApp,
+  useCookie,
+  useRuntimeConfig
+} from "#imports";
+export default defineNuxtPlugin({
+  name: "authupKit",
+  enforce: "pre",
+  dependsOn: ["authupPinia"],
+  setup(ctx) {
+    const runtimeConfig = useRuntimeConfig();
+    let apiURL;
+    let apiURLServer;
+    let cookieDomain;
+    const runtimeOptions = runtimeConfig.public.authup;
+    if (import.meta.server && (runtimeOptions.apiURLServer || runtimeOptions.apiURLServerRuntimeKey)) {
+      if (runtimeOptions.apiURLServer) {
+        apiURLServer = runtimeOptions.apiURLServer;
+      }
+      if (runtimeOptions.apiURLServerRuntimeKey) {
+        let pathValue = getPathValue(runtimeConfig, runtimeOptions.apiURLServerRuntimeKey);
+        if (typeof pathValue === "string") {
+          apiURLServer = pathValue;
+        }
+        pathValue = getPathValue(runtimeConfig.public, runtimeOptions.apiURLServerRuntimeKey);
+        if (typeof pathValue === "string") {
+          apiURLServer = pathValue;
+        }
+      }
+    }
+    if (runtimeOptions.apiURL) {
+      apiURL = runtimeOptions.apiURL;
+    }
+    if (runtimeOptions.apiURLRuntimeKey) {
+      const pathValue = getPathValue(runtimeConfig.public, runtimeOptions.apiURLRuntimeKey);
+      if (typeof pathValue === "string") {
+        apiURL = pathValue;
+      }
+    }
+    if (runtimeOptions.cookieDomain) {
+      cookieDomain = runtimeOptions.cookieDomain;
+    }
+    if (runtimeOptions.cookieDomainRuntimeKey) {
+      const pathValue = getPathValue(runtimeConfig.public, runtimeOptions.cookieDomainRuntimeKey);
+      if (typeof pathValue === "string") {
+        cookieDomain = pathValue;
+      }
+    }
+    if (!cookieDomain) {
+      const { hostname } = new URL(apiURL || "http://localhost:3000");
+      cookieDomain = hostname;
+    }
+    if (cookieDomain === "127.0.0.1") {
+      cookieDomain = "localhost";
+    }
+    const cookieOptions = {
+      domain: cookieDomain || "localhost"
+    };
+    install(ctx.vueApp, {
+      pinia: ctx.$pinia,
+      baseURL: apiURLServer || apiURL || "http://localhost:3000",
+      cookieSet: (key, value) => {
+        const app = tryUseNuxtApp();
+        if (app) {
+          const cookie = useCookie(key, cookieOptions);
+          cookie.value = value;
+        }
+      },
+      cookieUnset: (key) => {
+        const app = tryUseNuxtApp();
+        if (app) {
+          const cookie = useCookie(key, cookieOptions);
+          cookie.value = null;
+        }
+      },
+      cookieGet: (key) => {
+        const app = tryUseNuxtApp();
+        if (app) {
+          const cookie = useCookie(key, cookieOptions);
+          return cookie.value;
+        }
+        return null;
+      },
+      isServer: import.meta.server
+    });
+  }
+});

package/dist/runtime/types.d.ts

@@ -0,0 +1,17 @@
+export type AuthupRuntimeOptions = {
+    apiURL?: string;
+    apiURLRuntimeKey?: string;
+    /**
+     * Separate apiURL for server side rendering.
+     */
+    apiURLServer?: string;
+    /**
+     * Separate extraction of apiURL for server side rendering.
+     */
+    apiURLServerRuntimeKey?: string;
+    cookieDomain?: string;
+    cookieDomainRuntimeKey?: string;
+    homeRoute?: string;
+    loginRoute?: string;
+    logoutRoute?: string;
+};

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.js'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module'

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@authup/client-web-nuxt",
+    "type": "module",
+    "version": "1.0.0-beta.20",
+    "description": "Nuxt module for the authup ecosystem",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/authup/authup.git",
+        "directory": "packages/client-web-nuxt"
+    },
+    "license": "Apache-2.0",
+    "exports": {
+        ".": {
+            "types": "./dist/types.d.ts",
+            "import": "./dist/module.mjs",
+            "require": "./dist/module.cjs"
+        }
+    },
+    "main": "./dist/module.cjs",
+    "module": "./dist/module.mjs",
+    "types": "./dist/types.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "nuxt-module-build prepare && nuxt-module-build build",
+        "prepack": "nuxt-module-build build",
+        "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+        "lint": "eslint ."
+    },
+    "dependencies": {
+        "@authup/kit": "^1.0.0-beta.20",
+        "@authup/client-web-kit": "^1.0.0-beta.20",
+        "@nuxt/kit": "^3.13.2",
+        "pathtrace": "^1.1.0",
+        "smob": "^1.5.0"
+    },
+    "devDependencies": {
+        "@nuxt/module-builder": "^0.8.4",
+        "nuxt": "^3.13.2",
+        "pinia": "^2.2.4"
+    },
+    "peerDependencies": {
+        "pinia": "^2.2.4"
+    }
+}