@qelos/integrator-nuxt 4.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+Polyform Shield License 1.0.0
+
+Copyright (c) 2025 Velocitech LTD
+
+Your use of this software is governed by the Polyform Shield License 1.0.0.
+
+You may obtain a copy of the License at:
+https://polyformproject.org/licenses/shield/1.0.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+Additional Terms – Exception Notice:
+
+The author of this software grants additional permissions beyond the Polyform Shield License 1.0.0:
+
+✅ All uses of the software are permitted — including modification, distribution, commercial use, and sublicensing — as long as the software is not used to create, offer, or operate any product or service that competes directly with Qelos (https://qelos.io), a no-code platform for building AI-assisted SaaS applications.
+
+❌ "Direct competition" includes platforms, tools, or services that enable users to visually or programmatically create SaaS applications with the assistance of artificial intelligence.
+
+This exception does not modify the terms of the original Polyform Shield License for other users and applies only by explicit permission of the licensor.

package/README.md

@@ -0,0 +1,185 @@
+# @qelos/integrator-nuxt
+
+Nuxt 3 integrator for [Qelos](https://qelos.io). Adds a server middleware that
+identifies the current user and active workspace via the
+[`@qelos/sdk`](https://www.npmjs.com/package/@qelos/sdk) before your own
+Nitro/Nuxt route handlers run, and exposes them through the H3 event context.
+
+A token-refresh hook keeps the access token fresh: when the SDK detects an
+expired access token, it transparently refreshes it — either through the
+request's refresh token or, for cookie-only sessions, through the access
+cookie itself — and writes the rotated cookie pair back on the response.
+
+## Install
+
+```bash
+pnpm add @qelos/integrator-nuxt
+```
+
+## Configure
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['@qelos/integrator-nuxt'],
+  qelos: {
+    appUrl: 'https://your-qelos-app.com',
+    // Optional — defaults shown:
+    accessTokenCookie: 'q_access_token',
+    refreshTokenCookie: 'q_refresh_token',
+    requireAuth: false,
+    skipPaths: ['/api/_auth', '/health'],
+  },
+});
+```
+
+You can also override any field at runtime via `NUXT_QELOS_*` env vars (Nuxt
+runtime-config conventions apply).
+
+## Use in server routes
+
+The recommended wrapper, `defineQelosEventHandler`, gives you a typed `qelos`
+context as a second argument and asserts the middleware ran:
+
+```ts
+// server/api/products.ts
+import { defineQelosEventHandler } from '@qelos/integrator-nuxt';
+
+export default defineQelosEventHandler(async ({ qelos }) => {
+  return qelos.sdk.entities('products').getList();
+});
+```
+
+Pass `{ requireAuth: true }` to short-circuit anonymous requests with `401`:
+
+```ts
+// server/api/me.ts
+import { defineQelosEventHandler } from '@qelos/integrator-nuxt';
+
+export default defineQelosEventHandler(({ qelos }) => {
+  return { user: qelos.user, workspace: qelos.workspace };
+}, { requireAuth: true });
+```
+
+Or use `defineEventHandler` directly — `event.context.qelos` is also populated:
+
+```ts
+// server/api/me.ts
+export default defineEventHandler((event) => {
+  const { user, workspace, sdk } = event.context.qelos!;
+  if (!user) {
+    throw createError({ statusCode: 401 });
+  }
+  return { user, workspace };
+});
+```
+
+`event.context.qelos` is typed as `QelosRequestContext`:
+
+| field        | description                                                |
+|--------------|------------------------------------------------------------|
+| `user`       | `IUser` from `@qelos/sdk` or `null` when anonymous.         |
+| `workspace`  | The active `IWorkspace` for the request, or `null`.         |
+| `workspaces` | All workspaces the user has access to.                      |
+| `sdk`        | A request-scoped `QelosSDK` instance bound to the tokens.   |
+| `tokens`     | The current access/refresh token pair (mutated on refresh). |
+
+## Use in components / pages
+
+`useQelos()` is auto-imported in your Vue components and reads the identity
+that was resolved by the server middleware. Values are seeded during SSR and
+hydrated on the client through the Nuxt payload, so no extra round-trip is
+needed.
+
+```vue
+<script setup lang="ts">
+const { user, workspace, workspaces, isAuthenticated } = useQelos();
+</script>
+
+<template>
+  <div v-if="isAuthenticated">
+    Hi {{ user.firstName }} — workspace: {{ workspace?.name }}
+  </div>
+</template>
+```
+
+For data calls from the browser, prefer hitting your own server routes (so
+refresh-token rotation stays on the server):
+
+```vue
+<script setup lang="ts">
+const { data: products } = await useFetch('/api/products');
+</script>
+```
+
+If you need direct browser access to the Qelos API, use
+[`@qelos/web-sdk`](https://www.npmjs.com/package/@qelos/web-sdk) instead — the
+server-side SDK in this package is bound to per-request cookies and isn't
+intended for client use.
+
+## Token refresh
+
+When the access token is rejected, the SDK tries to recover, in order:
+
+1. The **refresh token** (`q_refresh_token`) via
+   `sdk.authentication.refreshToken()` — issues a new access + refresh pair.
+2. The **cookie token** (the access token cookie itself) via
+   `sdk.authentication.refreshCookieToken()` — used for cookie-only sessions
+   that do not carry a separate refresh token (e.g. social-auth flows).
+
+After a successful refresh the middleware fires the `onTokenRefresh` hook.
+The default implementation writes the new tokens back to the response cookies
+(`HttpOnly`, `SameSite=Lax`).
+
+### Manual cookie refresh
+
+Long-lived integrator-hosted sessions can also call the SDK directly to
+proactively refresh the cookie token, e.g. from a Nitro route handler:
+
+```ts
+// server/api/session/refresh.post.ts
+import { defineQelosEventHandler } from '@qelos/integrator-nuxt';
+
+export default defineQelosEventHandler(async ({ qelos }) => {
+  const result = await qelos.sdk.authentication.refreshCookieToken();
+  // result.headers['set-cookie'] — fresh cookie value to forward
+  return { user: result.payload.user };
+});
+```
+
+## Custom workspace resolution / refresh hook
+
+If the default behavior (first workspace from `sdk.workspaces.getList()` and a
+cookie-based refresh writeback) doesn't fit your app, register your own
+middleware instead of (or in addition to) the module's default handler:
+
+```ts
+// server/middleware/qelos.ts
+import { createQelosMiddleware } from '@qelos/integrator-nuxt';
+
+export default createQelosMiddleware({
+  config: useRuntimeConfig().qelos,
+  resolveWorkspace: ({ user, workspaces }) =>
+    workspaces.find(w => w._id === user.metadata?.activeWorkspace) || workspaces[0] || null,
+  onTokenRefresh: async ({ event, newTokens }) => {
+    // your own persistence — DB, signed cookie, KV, etc.
+    setCookie(event, 'q_access_token', newTokens.accessToken, { httpOnly: true });
+    setCookie(event, 'q_refresh_token', newTokens.refreshToken, { httpOnly: true });
+  },
+});
+```
+
+To skip the module's default registration, set `qelos.disableMiddleware: true`
+in `nuxt.config.ts`.
+
+## API token mode
+
+For service-to-service deployments where every request shares one Qelos API
+token, set `apiToken` and the middleware will skip the cookie/refresh flow:
+
+```ts
+qelos: {
+  appUrl: 'https://your-qelos-app.com',
+  apiToken: process.env.QELOS_API_TOKEN,
+}
+```

package/dist/event-handler.d.ts

@@ -0,0 +1,32 @@
+import { type EventHandlerRequest, type EventHandlerResponse, type H3Event } from 'h3';
+import type { QelosRequestContext } from './types';
+export interface QelosEventContext<T extends EventHandlerRequest = EventHandlerRequest> {
+    event: H3Event<T>;
+    qelos: QelosRequestContext;
+}
+export interface DefineQelosEventHandlerOptions {
+    /**
+     * Reject the request with `401 Unauthorized` when no authenticated user is
+     * resolved on `event.context.qelos`. Defaults to `false`, mirroring the
+     * module-level `qelos.requireAuth` behavior.
+     */
+    requireAuth?: boolean;
+}
+export type QelosEventHandler<Request extends EventHandlerRequest = EventHandlerRequest, Response extends EventHandlerResponse = EventHandlerResponse> = (ctx: QelosEventContext<Request>) => Response;
+/**
+ * Wrap a Nitro/H3 event handler so that the Qelos request context (user,
+ * workspace, workspaces, sdk, tokens) is available as a second argument and
+ * already typed. Requires the `@qelos/integrator-nuxt` module to be enabled
+ * (or `createQelosMiddleware` to be registered manually) so that
+ * `event.context.qelos` is populated.
+ *
+ * ```ts
+ * // server/api/products.ts
+ * import { defineQelosEventHandler } from '@qelos/integrator-nuxt';
+ *
+ * export default defineQelosEventHandler(async ({ qelos }) => {
+ *   return qelos.sdk.entities('products').getList();
+ * });
+ * ```
+ */
+export declare function defineQelosEventHandler<Request extends EventHandlerRequest = EventHandlerRequest, Response extends EventHandlerResponse = EventHandlerResponse>(handler: QelosEventHandler<Request, Response>, options?: DefineQelosEventHandlerOptions): import("h3").EventHandler<Request, any>;

package/dist/event-handler.js

@@ -0,0 +1,33 @@
+import { defineEventHandler, createError, } from 'h3';
+/**
+ * Wrap a Nitro/H3 event handler so that the Qelos request context (user,
+ * workspace, workspaces, sdk, tokens) is available as a second argument and
+ * already typed. Requires the `@qelos/integrator-nuxt` module to be enabled
+ * (or `createQelosMiddleware` to be registered manually) so that
+ * `event.context.qelos` is populated.
+ *
+ * ```ts
+ * // server/api/products.ts
+ * import { defineQelosEventHandler } from '@qelos/integrator-nuxt';
+ *
+ * export default defineQelosEventHandler(async ({ qelos }) => {
+ *   return qelos.sdk.entities('products').getList();
+ * });
+ * ```
+ */
+export function defineQelosEventHandler(handler, options = {}) {
+    return defineEventHandler(async (event) => {
+        const qelos = event.context.qelos;
+        if (!qelos) {
+            throw createError({
+                statusCode: 500,
+                statusMessage: '[@qelos/integrator-nuxt] event.context.qelos is missing. Add the module to nuxt.config or register createQelosMiddleware manually.',
+            });
+        }
+        if (options.requireAuth && !qelos.user) {
+            throw createError({ statusCode: 401, statusMessage: 'Unauthorized' });
+        }
+        return handler({ event, qelos });
+    });
+}
+//# sourceMappingURL=event-handler.js.map

package/dist/event-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-handler.js","sourceRoot":"","sources":["../src/event-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,WAAW,GAIZ,MAAM,IAAI,CAAC;AAsBZ;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,uBAAuB,CAIrC,OAA6C,EAC7C,UAA0C,EAAE;IAE5C,OAAO,kBAAkB,CAAU,KAAK,EAAE,KAAK,EAAE,EAAE;QACjD,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAClC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,WAAW,CAAC;gBAChB,UAAU,EAAE,GAAG;gBACf,aAAa,EACX,oIAAoI;aACvI,CAAC,CAAC;QACL,CAAC;QACD,IAAI,OAAO,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YACvC,MAAM,WAAW,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,aAAa,EAAE,cAAc,EAAE,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,OAAO,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAa,CAAC;IAC/C,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/middleware.d.ts

@@ -0,0 +1,23 @@
+import { type H3Event } from 'h3';
+import type { IUser } from '@qelos/sdk/dist/authentication';
+import type { IWorkspace } from '@qelos/sdk/workspaces';
+import type { QelosNuxtRuntimeConfig, TokenRefreshHook } from './types';
+export interface CreateMiddlewareOptions {
+    config: QelosNuxtRuntimeConfig;
+    /**
+     * Hook invoked after a successful token refresh. The default implementation
+     * writes the new tokens back to the response cookies.
+     */
+    onTokenRefresh?: TokenRefreshHook;
+    /**
+     * Resolve the active workspace for a request. Defaults to picking the first
+     * workspace returned from `sdk.workspaces.getList()`.
+     */
+    resolveWorkspace?: (params: {
+        event: H3Event;
+        user: IUser;
+        workspaces: IWorkspace[];
+    }) => IWorkspace | null | Promise<IWorkspace | null>;
+}
+export declare function createQelosMiddleware(options: CreateMiddlewareOptions): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export type QelosMiddleware = ReturnType<typeof createQelosMiddleware>;

package/dist/middleware.js

@@ -0,0 +1,96 @@
+import { defineEventHandler, getCookie, getRequestHeader, setCookie, createError, } from 'h3';
+import { createRequestSdk } from './sdk-factory';
+const DEFAULT_ACCESS_COOKIE = 'q_access_token';
+const DEFAULT_REFRESH_COOKIE = 'q_refresh_token';
+function readTokens(event, config) {
+    const accessCookie = config.accessTokenCookie || DEFAULT_ACCESS_COOKIE;
+    const refreshCookie = config.refreshTokenCookie || DEFAULT_REFRESH_COOKIE;
+    const cookieAccess = getCookie(event, accessCookie);
+    const cookieRefresh = getCookie(event, refreshCookie);
+    const authHeader = getRequestHeader(event, 'authorization');
+    const headerAccess = authHeader && authHeader.toLowerCase().startsWith('bearer ')
+        ? authHeader.slice(7).trim()
+        : undefined;
+    return {
+        accessToken: headerAccess || cookieAccess || undefined,
+        refreshToken: cookieRefresh || undefined,
+    };
+}
+function writeTokensToCookies(event, config, tokens) {
+    const accessCookie = config.accessTokenCookie || DEFAULT_ACCESS_COOKIE;
+    const refreshCookie = config.refreshTokenCookie || DEFAULT_REFRESH_COOKIE;
+    const cookieOptions = {
+        httpOnly: true,
+        secure: true,
+        sameSite: 'lax',
+        path: '/',
+    };
+    setCookie(event, accessCookie, tokens.accessToken, cookieOptions);
+    if (tokens.refreshToken) {
+        setCookie(event, refreshCookie, tokens.refreshToken, cookieOptions);
+    }
+}
+function shouldSkip(event, config) {
+    if (!config.skipPaths?.length) {
+        return false;
+    }
+    const path = event.path || event.node?.req?.url || '';
+    return config.skipPaths.some((prefix) => path.startsWith(prefix));
+}
+export function createQelosMiddleware(options) {
+    const { config, resolveWorkspace } = options;
+    const onTokenRefresh = options.onTokenRefresh
+        || (async ({ event, newTokens }) => {
+            writeTokensToCookies(event, config, newTokens);
+        });
+    return defineEventHandler(async (event) => {
+        if (shouldSkip(event, config)) {
+            return;
+        }
+        const tokens = readTokens(event, config);
+        const sdk = createRequestSdk({ config, tokens, event, onTokenRefresh });
+        const ctx = {
+            user: null,
+            workspace: null,
+            workspaces: [],
+            sdk,
+            tokens,
+        };
+        event.context.qelos = ctx;
+        const hasAuthMaterial = Boolean(config.apiToken || tokens.accessToken || tokens.refreshToken);
+        if (!hasAuthMaterial) {
+            if (config.requireAuth) {
+                throw createError({ statusCode: 401, statusMessage: 'Unauthorized' });
+            }
+            return;
+        }
+        try {
+            ctx.user = await sdk.authentication.getLoggedInUser();
+        }
+        catch (err) {
+            if (config.requireAuth) {
+                throw createError({ statusCode: 401, statusMessage: 'Unauthorized' });
+            }
+            return;
+        }
+        try {
+            ctx.workspaces = await sdk.workspaces.getList();
+        }
+        catch {
+            ctx.workspaces = [];
+        }
+        if (ctx.user && ctx.workspaces.length) {
+            if (resolveWorkspace) {
+                ctx.workspace = await resolveWorkspace({
+                    event,
+                    user: ctx.user,
+                    workspaces: ctx.workspaces,
+                }) || null;
+            }
+            else {
+                ctx.workspace = ctx.workspaces[0] || null;
+            }
+        }
+    });
+}
+//# sourceMappingURL=middleware.js.map

package/dist/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"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"}

package/dist/module.d.ts

@@ -0,0 +1,15 @@
+import type { QelosNuxtRuntimeConfig } from './types';
+export interface QelosNuxtModuleOptions extends QelosNuxtRuntimeConfig {
+    /**
+     * Disable registration of the default server middleware. Use this if you
+     * want to call `createQelosMiddleware` yourself from your own server route.
+     */
+    disableMiddleware?: boolean;
+}
+declare const _default: import("nuxt/schema").NuxtModule<QelosNuxtModuleOptions, QelosNuxtModuleOptions, false>;
+export default _default;
+export { createQelosMiddleware } from './middleware';
+export { createRequestSdk } from './sdk-factory';
+export { defineQelosEventHandler } from './event-handler';
+export type { DefineQelosEventHandlerOptions, QelosEventContext, QelosEventHandler, } from './event-handler';
+export type { QelosNuxtRuntimeConfig, QelosRequestContext, QelosTokenPair, ResolvedTokens, TokenRefreshContext, TokenRefreshHook, } from './types';

package/dist/module.js

@@ -0,0 +1,49 @@
+import { defineNuxtModule, addServerHandler, addImportsDir, createResolver, addTypeTemplate, } from '@nuxt/kit';
+export default defineNuxtModule({
+    meta: {
+        name: '@qelos/integrator-nuxt',
+        configKey: 'qelos',
+        compatibility: {
+            nuxt: '^3.0.0',
+        },
+    },
+    defaults: {
+        appUrl: '',
+    },
+    setup(options, nuxt) {
+        if (!options.appUrl) {
+            throw new Error('[@qelos/integrator-nuxt] `qelos.appUrl` must be set in nuxt.config');
+        }
+        const { resolve } = createResolver(import.meta.url);
+        const { disableMiddleware, ...runtimeConfig } = options;
+        nuxt.options.runtimeConfig.qelos = {
+            ...nuxt.options.runtimeConfig.qelos,
+            ...runtimeConfig,
+        };
+        if (!disableMiddleware) {
+            addServerHandler({
+                handler: resolve('./runtime/server-handler'),
+                middleware: true,
+            });
+        }
+        addImportsDir(resolve('./runtime/composables'));
+        addTypeTemplate({
+            filename: 'types/qelos-nuxt.d.ts',
+            getContents: () => `
+import type { QelosRequestContext } from '@qelos/integrator-nuxt/types';
+
+declare module 'h3' {
+  interface H3EventContext {
+    qelos?: QelosRequestContext;
+  }
+}
+
+export {};
+`,
+        });
+    },
+});
+export { createQelosMiddleware } from './middleware';
+export { createRequestSdk } from './sdk-factory';
+export { defineQelosEventHandler } from './event-handler';
+//# sourceMappingURL=module.js.map

package/dist/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,eAAe,GAChB,MAAM,WAAW,CAAC;AAWnB,eAAe,gBAAgB,CAAyB;IACtD,IAAI,EAAE;QACJ,IAAI,EAAE,wBAAwB;QAC9B,SAAS,EAAE,OAAO;QAClB,aAAa,EAAE;YACb,IAAI,EAAE,QAAQ;SACf;KACF;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,EAAE;KACX;IACD,KAAK,CAAC,OAAO,EAAE,IAAI;QACjB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;QACxF,CAAC;QAED,MAAM,EAAE,OAAO,EAAE,GAAG,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEpD,MAAM,EAAE,iBAAiB,EAAE,GAAG,aAAa,EAAE,GAAG,OAAO,CAAC;QAExD,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,GAAG;YACjC,GAAI,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,KAA6C;YAC5E,GAAG,aAAa;SACjB,CAAC;QAEF,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,gBAAgB,CAAC;gBACf,OAAO,EAAE,OAAO,CAAC,0BAA0B,CAAC;gBAC5C,UAAU,EAAE,IAAI;aACjB,CAAC,CAAC;QACL,CAAC;QAED,aAAa,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC;QAEhD,eAAe,CAAC;YACd,QAAQ,EAAE,uBAAuB;YACjC,WAAW,EAAE,GAAG,EAAE,CAAC;;;;;;;;;;CAUxB;SACI,CAAC,CAAC;IACL,CAAC;CACF,CAAC,CAAC;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,30 @@
+import type { IUser } from '@qelos/sdk/dist/authentication';
+import type { IWorkspace } from '@qelos/sdk/workspaces';
+interface Ref<T> {
+    value: T;
+}
+export interface UseQelosReturn {
+    /** The authenticated user (or `null` when anonymous). Hydrated from SSR. */
+    user: Ref<IUser | null>;
+    /** The active workspace for the user (or `null`). Hydrated from SSR. */
+    workspace: Ref<IWorkspace | null>;
+    /** All workspaces the user has access to. Hydrated from SSR. */
+    workspaces: Ref<IWorkspace[]>;
+    /** Convenience: `true` when `user` is set. */
+    isAuthenticated: Ref<boolean>;
+}
+/**
+ * Read the current Qelos identity (user / workspace / workspaces) on the
+ * client. Values are seeded on the server by the Qelos server middleware and
+ * sent to the client via Nuxt's payload. SDK calls from the browser should go
+ * through your own server routes (use `defineQelosEventHandler`) rather than
+ * directly, so refresh-token rotation stays server-side.
+ *
+ * ```vue
+ * <script setup lang="ts">
+ * const { user, workspace, isAuthenticated } = useQelos();
+ * </script>
+ * ```
+ */
+export declare function useQelos(): UseQelosReturn;
+export {};

package/dist/runtime/composables/useQelos.js

@@ -0,0 +1,38 @@
+// Auto-imported as `useQelos` by the @qelos/integrator-nuxt module. This file
+// is bundled by Nuxt/Nitro in the consuming app, so `#imports` resolves at
+// the consumer's build time.
+// @ts-ignore - resolved by Nuxt
+import { useState, useRequestEvent } from '#imports';
+function getServerContext() {
+    if (typeof window !== 'undefined')
+        return null;
+    try {
+        const event = useRequestEvent();
+        return (event && event.context && event.context.qelos) || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read the current Qelos identity (user / workspace / workspaces) on the
+ * client. Values are seeded on the server by the Qelos server middleware and
+ * sent to the client via Nuxt's payload. SDK calls from the browser should go
+ * through your own server routes (use `defineQelosEventHandler`) rather than
+ * directly, so refresh-token rotation stays server-side.
+ *
+ * ```vue
+ * <script setup lang="ts">
+ * const { user, workspace, isAuthenticated } = useQelos();
+ * </script>
+ * ```
+ */
+export function useQelos() {
+    const ctx = getServerContext();
+    const user = useState('qelos:user', () => ctx?.user ?? null);
+    const workspace = useState('qelos:workspace', () => ctx?.workspace ?? null);
+    const workspaces = useState('qelos:workspaces', () => ctx?.workspaces ?? []);
+    const isAuthenticated = useState('qelos:isAuthenticated', () => Boolean(ctx?.user));
+    return { user, workspace, workspaces, isAuthenticated };
+}
+//# sourceMappingURL=useQelos.js.map

package/dist/runtime/composables/useQelos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQelos.js","sourceRoot":"","sources":["../../../src/runtime/composables/useQelos.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,2EAA2E;AAC3E,6BAA6B;AAC7B,gCAAgC;AAChC,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAsBrD,SAAS,gBAAgB;IACvB,IAAI,OAAO,MAAM,KAAK,WAAW;QAAE,OAAO,IAAI,CAAC;IAC/C,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,eAAe,EAAE,CAAC;QAChC,OAAO,CAAC,KAAK,IAAI,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC;IACjE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,QAAQ;IACtB,MAAM,GAAG,GAAG,gBAAgB,EAAE,CAAC;IAC/B,MAAM,IAAI,GAAG,QAAQ,CAAe,YAAY,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,IAAI,IAAI,IAAI,CAAC,CAAC;IAC3E,MAAM,SAAS,GAAG,QAAQ,CAAoB,iBAAiB,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,SAAS,IAAI,IAAI,CAAC,CAAC;IAC/F,MAAM,UAAU,GAAG,QAAQ,CAAe,kBAAkB,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,UAAU,IAAI,EAAE,CAAC,CAAC;IAC3F,MAAM,eAAe,GAAG,QAAQ,CAC9B,uBAAuB,EACvB,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CACzB,CAAC;IACF,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,EAAE,CAAC;AAC1D,CAAC"}

package/dist/runtime/server-handler.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server-handler.js

@@ -0,0 +1,10 @@
+// This file is registered as a Nuxt server middleware by `module.ts`.
+// It is bundled by Nitro, so `#imports` resolves at the consuming-app build
+// time (not at this package's `tsc` build).
+// @ts-ignore - resolved by Nitro
+import { useRuntimeConfig } from '#imports';
+import { createQelosMiddleware } from '../middleware';
+const runtimeConfig = useRuntimeConfig();
+const config = (runtimeConfig.qelos || {});
+export default createQelosMiddleware({ config });
+//# sourceMappingURL=server-handler.js.map

package/dist/runtime/server-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-handler.js","sourceRoot":"","sources":["../../src/runtime/server-handler.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,4EAA4E;AAC5E,4CAA4C;AAC5C,iCAAiC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAGtD,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAC;AACzC,MAAM,MAAM,GAAG,CAAC,aAAa,CAAC,KAAK,IAAI,EAAE,CAA2B,CAAC;AAErE,eAAe,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC"}

package/dist/sdk-factory.d.ts

@@ -0,0 +1,15 @@
+import QelosSDK from '@qelos/sdk';
+import type { QelosNuxtRuntimeConfig, QelosTokenPair, TokenRefreshHook } from './types';
+import type { H3Event } from 'h3';
+export interface CreateSdkParams {
+    config: QelosNuxtRuntimeConfig;
+    /**
+     * Tokens for the current request. The factory mutates this object in
+     * place when a token refresh occurs, so callers can read the latest pair
+     * after the SDK has been used.
+     */
+    tokens: QelosTokenPair;
+    event: H3Event;
+    onTokenRefresh?: TokenRefreshHook;
+}
+export declare function createRequestSdk({ config, tokens, event, onTokenRefresh }: CreateSdkParams): QelosSDK;