@croct/plug-nuxt 0.0.1 → 0.1.0

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,3 @@
+declare const _default: NuxtModule<TOptions, TOptions, false>;
+
+export { _default as default };

package/dist/module.d.ts

@@ -0,0 +1,3 @@
+declare const _default: NuxtModule<TOptions, TOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "@croct/plug-nuxt",
+  "configKey": "croct",
+  "compatibility": {
+    "nuxt": ">=3.0.0"
+  },
+  "version": "0.1.0",
+  "builder": {
+    "@nuxt/module-builder": "0.8.4",
+    "unbuild": "2.0.0"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,128 @@
+import { join } from 'path';
+import { defineNuxtModule, createResolver, addTemplate, addPlugin, addServerHandler, addImportsDir, addServerImportsDir } from '@nuxt/kit';
+
+const DEFAULT_CLIENT_ID_COOKIE_DURATION = 365 * 24 * 60 * 60;
+const DEFAULT_USER_TOKEN_COOKIE_DURATION = 7 * 24 * 60 * 60;
+const DEFAULT_TOKEN_DURATION = 24 * 60 * 60;
+const module = defineNuxtModule({
+  meta: {
+    name: "@croct/plug-nuxt",
+    configKey: "croct",
+    compatibility: {
+      nuxt: ">=3.0.0"
+    }
+  },
+  defaults: {
+    debug: false,
+    test: false,
+    defaultPreferredLocale: "",
+    disableUserTokenAuthentication: false,
+    tokenDuration: DEFAULT_TOKEN_DURATION
+  },
+  setup: function(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    const cookieConfig = {
+      clientId: {
+        name: options.cookie?.clientId?.name ?? "ct.client_id",
+        domain: options.cookie?.clientId?.domain ?? "",
+        duration: options.cookie?.clientId?.duration ?? DEFAULT_CLIENT_ID_COOKIE_DURATION
+      },
+      userToken: {
+        name: options.cookie?.userToken?.name ?? "ct.user_token",
+        domain: options.cookie?.userToken?.domain ?? "",
+        duration: options.cookie?.userToken?.duration ?? DEFAULT_USER_TOKEN_COOKIE_DURATION
+      },
+      previewToken: {
+        name: options.cookie?.previewToken?.name ?? "ct.preview_token",
+        domain: options.cookie?.previewToken?.domain ?? ""
+      }
+    };
+    nuxt.options.runtimeConfig.public.croct = {
+      appId: options.appId ?? "",
+      debug: options.debug ?? false,
+      test: options.test ?? false,
+      defaultPreferredLocale: options.defaultPreferredLocale ?? "",
+      defaultFetchTimeout: options.defaultFetchTimeout,
+      baseEndpointUrl: options.baseEndpointUrl,
+      cookie: cookieConfig
+    };
+    nuxt.options.runtimeConfig.croct = {
+      apiKey: "",
+      disableUserTokenAuthentication: options.disableUserTokenAuthentication ?? false,
+      tokenDuration: options.tokenDuration ?? DEFAULT_TOKEN_DURATION
+    };
+    const appResolver = createResolver(nuxt.options.rootDir);
+    const resolversCode = generateResolversModule(options, appResolver);
+    addTemplate({
+      filename: "croct/resolvers.ts",
+      write: true,
+      getContents: () => resolversCode
+    });
+    const nitroOptions = nuxt.options.nitro;
+    nitroOptions.alias = nitroOptions.alias ?? {};
+    nitroOptions.alias["#croct/resolvers"] = join(nuxt.options.buildDir, "croct/resolvers");
+    const clientOptionsCode = generateClientOptionsModule(options, appResolver);
+    addTemplate({
+      filename: "croct/client-options.ts",
+      write: true,
+      getContents: () => clientOptionsCode
+    });
+    nuxt.options.alias["#croct/client-options"] = join(nuxt.options.buildDir, "croct/client-options");
+    addPlugin(resolver.resolve("./runtime/plugin.client"));
+    addServerHandler({
+      handler: resolver.resolve("./runtime/server/middleware/croct"),
+      middleware: true
+    });
+    addImportsDir(resolver.resolve("./runtime/composables"));
+    addServerImportsDir(resolver.resolve("./runtime/server/composables"));
+    addServerHandler({
+      route: "/api/_croct/content",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/_croct/content.post")
+    });
+    addServerHandler({
+      route: "/api/_croct/evaluate",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/_croct/evaluate.post")
+    });
+    nuxt.hook("components:dirs", (dirs) => {
+      dirs.push({
+        path: resolver.resolve("./runtime/components"),
+        prefix: ""
+      });
+    });
+    nuxt.options.build.transpile.push("@croct/plug-vue", "@croct/sdk", "@croct/plug");
+    nuxt.options.vite = nuxt.options.vite ?? {};
+    nuxt.options.vite.ssr = nuxt.options.vite.ssr ?? {};
+    nuxt.options.vite.ssr.noExternal = nuxt.options.vite.ssr.noExternal ?? [];
+    if (Array.isArray(nuxt.options.vite.ssr.noExternal)) {
+      nuxt.options.vite.ssr.noExternal.push("@croct/plug-vue");
+    }
+    nuxt.options.experimental.asyncContext = true;
+  }
+});
+function generateResolversModule(options, appResolver) {
+  const lines = [];
+  if (options.localeResolver !== void 0) {
+    lines.push(`export { default as localeResolver } from '${appResolver.resolve(options.localeResolver)}';`);
+  } else {
+    lines.push("export const localeResolver = undefined;");
+  }
+  if (options.userIdResolver !== void 0) {
+    lines.push(`export { default as userIdResolver } from '${appResolver.resolve(options.userIdResolver)}';`);
+  } else {
+    lines.push("export const userIdResolver = undefined;");
+  }
+  return lines.join("\n");
+}
+function generateClientOptionsModule(options, appResolver) {
+  const lines = [];
+  if (options.urlSanitizer !== void 0) {
+    lines.push(`export { default as urlSanitizer } from '${appResolver.resolve(options.urlSanitizer)}';`);
+  } else {
+    lines.push("export const urlSanitizer = undefined;");
+  }
+  return lines.join("\n");
+}
+
+export { module as default };

package/dist/runtime/components/Personalization.d.ts

@@ -0,0 +1,44 @@
+import type { PropType } from 'vue';
+import type { JsonObject } from '@croct/plug/sdk/json';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    query: {
+        type: StringConstructor;
+        required: true;
+    };
+    fallback: {
+        type: PropType<unknown>;
+        default: undefined;
+    };
+    timeout: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    attributes: {
+        type: PropType<JsonObject>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    query: {
+        type: StringConstructor;
+        required: true;
+    };
+    fallback: {
+        type: PropType<unknown>;
+        default: undefined;
+    };
+    timeout: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    attributes: {
+        type: PropType<JsonObject>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    fallback: undefined;
+    timeout: number;
+    attributes: JsonObject;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/components/Personalization.js

@@ -0,0 +1,46 @@
+import { defineComponent } from "vue";
+import { useAsyncData } from "#app";
+export default defineComponent({
+  name: "Personalization",
+  props: {
+    query: {
+      type: String,
+      required: true
+    },
+    fallback: {
+      type: [Object, String, Number, Boolean, null],
+      default: void 0
+    },
+    timeout: {
+      type: Number,
+      default: void 0
+    },
+    attributes: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup: async function(props, { slots }) {
+    const options = {
+      ...props.fallback !== void 0 ? { fallback: props.fallback } : {},
+      ...props.timeout !== void 0 ? { timeout: props.timeout } : {},
+      ...props.attributes !== void 0 ? { attributes: props.attributes } : {}
+    };
+    const { data, pending, error } = await useAsyncData(
+      `croct:pers:${props.query}:${JSON.stringify(options)}`,
+      () => $fetch("/api/_croct/evaluate", {
+        method: "POST",
+        body: { query: props.query, ...options }
+      })
+    );
+    return () => {
+      if (error.value !== null) {
+        return slots.error?.({ error: error.value });
+      }
+      if (pending.value) {
+        return slots.loading?.();
+      }
+      return slots.default?.({ result: data.value });
+    };
+  }
+});

package/dist/runtime/components/Slot.d.ts

@@ -0,0 +1,45 @@
+import type { PropType } from 'vue';
+import type { VersionedSlotId } from '@croct/plug/slot';
+import type { JsonObject } from '@croct/plug/sdk/json';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    id: {
+        type: PropType<VersionedSlotId>;
+        required: true;
+    };
+    fallback: {
+        type: PropType<JsonObject>;
+        default: undefined;
+    };
+    preferredLocale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    attributes: {
+        type: PropType<JsonObject>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    id: {
+        type: PropType<VersionedSlotId>;
+        required: true;
+    };
+    fallback: {
+        type: PropType<JsonObject>;
+        default: undefined;
+    };
+    preferredLocale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    attributes: {
+        type: PropType<JsonObject>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    fallback: JsonObject;
+    attributes: JsonObject;
+    preferredLocale: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/components/Slot.js

@@ -0,0 +1,52 @@
+import { defineComponent } from "vue";
+import { useAsyncData } from "#app";
+import { resolveLocale } from "../utils/locale.js";
+export default defineComponent({
+  name: "Slot",
+  props: {
+    id: {
+      type: String,
+      required: true
+    },
+    fallback: {
+      type: [Object, String, Number, Boolean, null],
+      default: void 0
+    },
+    preferredLocale: {
+      type: String,
+      default: void 0
+    },
+    attributes: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup: async function(props, { slots }) {
+    const locale = resolveLocale(props.preferredLocale);
+    const options = {
+      ...props.fallback !== void 0 ? { fallback: props.fallback } : {},
+      ...locale !== void 0 ? { preferredLocale: locale } : {},
+      ...props.attributes !== void 0 ? { attributes: props.attributes } : {}
+    };
+    const { data, error } = await useAsyncData(
+      `croct:slot:${props.id}:${JSON.stringify(options)}`,
+      () => $fetch("/api/_croct/content", {
+        method: "POST",
+        body: { slotId: props.id, ...options }
+      })
+    );
+    return () => {
+      const response = data.value;
+      if (response !== null && typeof response === "object" && "content" in response) {
+        return slots.default?.({
+          content: response.content,
+          ...response.metadata !== void 0 ? { metadata: response.metadata } : {}
+        });
+      }
+      if (error.value !== null) {
+        return slots.error?.({ error: error.value });
+      }
+      return slots.loading?.();
+    };
+  }
+});

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

@@ -0,0 +1,15 @@
+import type { JsonObject } from '@croct/plug/sdk/json';
+import type { VersionedSlotId, VersionedSlotMap } from '@croct/plug/slot';
+import type { FetchResponseOptions } from '@croct/sdk/contentFetcher';
+import type { FetchResponse } from '@croct/plug/api';
+import type { AsyncData, NuxtError } from '#app';
+import type { DynamicContentOptions } from '../server/composables/fetchContent.js';
+export type UseContentOptions<T extends JsonObject = JsonObject> = DynamicContentOptions<T>;
+type UseContentHook = {
+    <P extends JsonObject, O extends FetchResponseOptions = FetchResponseOptions>(id: keyof VersionedSlotMap extends never ? string : never, options?: O & UseContentOptions): AsyncData<FetchResponse<VersionedSlotId, P, never, O>, NuxtError | null>;
+    <P extends JsonObject, F extends JsonObject, O extends FetchResponseOptions = FetchResponseOptions>(id: keyof VersionedSlotMap extends never ? string : never, options: O & UseContentOptions<F>): AsyncData<FetchResponse<VersionedSlotId, P, F, O>, NuxtError | null>;
+    <S extends VersionedSlotId, O extends FetchResponseOptions = FetchResponseOptions>(id: S, options?: O & UseContentOptions): AsyncData<FetchResponse<S, JsonObject, never, O>, NuxtError | null>;
+    <F extends JsonObject, S extends VersionedSlotId, O extends FetchResponseOptions = FetchResponseOptions>(id: S, options: O & UseContentOptions<F>): AsyncData<FetchResponse<S, JsonObject, F, O>, NuxtError | null>;
+};
+export declare const useContent: UseContentHook;
+export {};

package/dist/runtime/composables/useContent.js

@@ -0,0 +1,19 @@
+import { useAsyncData } from "#app";
+import { resolveLocale } from "../utils/locale.js";
+function useContentNuxt(slotId, options = {}) {
+  const { preferredLocale, ...rest } = options;
+  const locale = resolveLocale(preferredLocale);
+  const resolvedOptions = {
+    ...locale !== void 0 ? { preferredLocale: locale } : {},
+    ...rest
+  };
+  const cacheKey = `croct:content:${slotId}:${JSON.stringify(resolvedOptions)}`;
+  return useAsyncData(
+    cacheKey,
+    () => $fetch("/api/_croct/content", {
+      method: "POST",
+      body: { slotId, ...resolvedOptions }
+    })
+  );
+}
+export const useContent = useContentNuxt;

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

@@ -0,0 +1 @@
+export { useCroct } from '@croct/plug-vue';

package/dist/runtime/composables/useCroct.js

@@ -0,0 +1 @@
+export { useCroct } from "@croct/plug-vue";

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

@@ -0,0 +1,12 @@
+import type { JsonValue } from '@croct/plug/sdk/json';
+import type { AsyncData, NuxtError } from '#app';
+import type { EvaluationOptions as BaseEvaluationOptions } from '../server/composables/evaluate.js';
+export type EvaluationOptions<T extends JsonValue = JsonValue> = BaseEvaluationOptions<T>;
+type UseEvaluationHook = {
+    <T extends JsonValue = JsonValue>(query: string, options?: EvaluationOptions<T>): AsyncData<T, NuxtError | null>;
+    <T extends JsonValue, F>(query: string, options: EvaluationOptions<T> & {
+        fallback: F;
+    }): AsyncData<T | F, NuxtError | null>;
+};
+export declare const useEvaluation: UseEvaluationHook;
+export {};

package/dist/runtime/composables/useEvaluation.js

@@ -0,0 +1,12 @@
+import { useAsyncData } from "#app";
+function useEvaluationNuxt(query, options = {}) {
+  const cacheKey = `croct:eval:${query}:${JSON.stringify(options)}`;
+  return useAsyncData(
+    cacheKey,
+    () => $fetch("/api/_croct/evaluate", {
+      method: "POST",
+      body: { query, ...options }
+    })
+  );
+}
+export const useEvaluation = useEvaluationNuxt;

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

@@ -0,0 +1,3 @@
+export { useContent } from './useContent.js';
+export { useCroct, useEvaluation, Slot, Personalization, createCroct } from '@croct/plug-vue';
+export type { UseContentOptions, UseContentResult, ContentMetadata, UseEvaluationOptions } from '@croct/plug-vue';

package/dist/runtime/csr/index.js

@@ -0,0 +1,2 @@
+export { useContent } from "./useContent.js";
+export { useCroct, useEvaluation, Slot, Personalization, createCroct } from "@croct/plug-vue";

package/dist/runtime/csr/useContent.d.ts

@@ -0,0 +1,2 @@
+import { useContent as useContentVue } from '@croct/plug-vue';
+export declare const useContent: typeof useContentVue;

package/dist/runtime/csr/useContent.js

@@ -0,0 +1,12 @@
+import { toValue } from "vue";
+import { useContent as useContentVue } from "@croct/plug-vue";
+import { resolveLocale } from "../utils/locale.js";
+function useContentNuxt(id, options = {}) {
+  const resolvedOptions = toValue(options);
+  const locale = resolveLocale(resolvedOptions.preferredLocale);
+  return useContentVue(id, {
+    ...resolvedOptions,
+    ...locale !== void 0 ? { preferredLocale: locale } : {}
+  });
+}
+export const useContent = useContentNuxt;

package/dist/runtime/plugin.client.d.ts

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

package/dist/runtime/plugin.client.js

@@ -0,0 +1,36 @@
+import { createCroct } from "@croct/plug-vue";
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { urlSanitizer } from "#croct/client-options";
+export default defineNuxtPlugin((nuxtApp) => {
+  const config = useRuntimeConfig().public.croct;
+  const plugin = createCroct({
+    appId: config.appId,
+    disableCidMirroring: true,
+    ...config.debug === true ? { debug: true } : {},
+    ...config.test === true ? { test: true } : {},
+    ...urlSanitizer !== void 0 ? { urlSanitizer } : {},
+    ...typeof config.baseEndpointUrl === "string" && config.baseEndpointUrl !== "" ? { baseEndpointUrl: config.baseEndpointUrl } : {},
+    ...config.defaultPreferredLocale !== "" ? { defaultPreferredLocale: config.defaultPreferredLocale } : {},
+    ...typeof config.defaultFetchTimeout === "number" ? { defaultFetchTimeout: config.defaultFetchTimeout } : {},
+    cookie: {
+      clientId: {
+        name: config.cookie.clientId.name,
+        maxAge: config.cookie.clientId.duration,
+        path: "/",
+        ...config.cookie.clientId.domain !== "" ? { domain: config.cookie.clientId.domain } : {}
+      },
+      userToken: {
+        name: config.cookie.userToken.name,
+        maxAge: config.cookie.userToken.duration,
+        path: "/",
+        ...config.cookie.userToken.domain !== "" ? { domain: config.cookie.userToken.domain } : {}
+      },
+      previewToken: {
+        name: config.cookie.previewToken.name,
+        path: "/",
+        ...config.cookie.previewToken.domain !== "" ? { domain: config.cookie.previewToken.domain } : {}
+      }
+    }
+  });
+  nuxtApp.vueApp.use(plugin);
+});

package/dist/runtime/server/api/_croct/content.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: globalThis.EventHandler<globalThis.EventHandlerRequest, Promise<globalThis.FetchResponse<any, import("@croct/json").JsonObject, never, import("@croct/sdk/contentFetcher").FetchResponseOptions>>>;
+export default _default;

package/dist/runtime/server/api/_croct/content.post.js

@@ -0,0 +1,6 @@
+import { readBody } from "h3";
+import { fetchContent } from "../../composables/fetchContent.js";
+export default defineEventHandler(async (event) => {
+  const { slotId, ...options } = await readBody(event);
+  return fetchContent(slotId, options);
+});

package/dist/runtime/server/api/_croct/evaluate.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: globalThis.EventHandler<globalThis.EventHandlerRequest, Promise<import("@croct/json").JsonValue>>;
+export default _default;

package/dist/runtime/server/api/_croct/evaluate.post.js

@@ -0,0 +1,6 @@
+import { readBody } from "h3";
+import { evaluate } from "../../composables/evaluate.js";
+export default defineEventHandler(async (event) => {
+  const { query, ...options } = await readBody(event);
+  return evaluate(query, options);
+});

package/dist/runtime/server/composables/anonymize.d.ts

@@ -0,0 +1 @@
+export declare function anonymize(): Promise<void>;

package/dist/runtime/server/composables/anonymize.js

@@ -0,0 +1,6 @@
+import { useEvent } from "#imports";
+import { issueToken } from "../utils/security.js";
+import { setUserTokenCookie } from "../utils/cookie.js";
+export async function anonymize() {
+  setUserTokenCookie(useEvent(), await issueToken());
+}

package/dist/runtime/server/composables/evaluate.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue } from '@croct/plug/sdk/json';
+import type { EvaluationOptions as BaseEvaluationOptions } from '@croct/plug/api';
+export type EvaluationOptions<T extends JsonValue = JsonValue> = Omit<BaseEvaluationOptions<T>, 'apiKey' | 'appId'>;
+export declare function evaluate<T extends JsonValue>(query: string, options?: EvaluationOptions<T>): Promise<T>;

package/dist/runtime/server/composables/evaluate.js

@@ -0,0 +1,37 @@
+import { evaluate as executeQuery } from "@croct/plug/api";
+import { FilteredLogger } from "@croct/sdk/logging/filteredLogger";
+import { ConsoleLogger } from "@croct/sdk/logging/consoleLogger";
+import { useEvent, useRuntimeConfig } from "#imports";
+import { getApiKey } from "../utils/security.js";
+export async function evaluate(query, options = {}) {
+  const event = useEvent();
+  const context = event.context.croct;
+  if (context === void 0) {
+    throw new Error(
+      "Croct's request context is missing. Make sure the @croct/plug-nuxt module is installed in your nuxt.config.ts. For help, see: https://croct.help/sdk/nuxt/missing-middleware"
+    );
+  }
+  const config = useRuntimeConfig();
+  const timeout = config.public.croct.defaultFetchTimeout;
+  return executeQuery(query, {
+    apiKey: getApiKey(),
+    clientIp: context.clientIp ?? "127.0.0.1",
+    ...context.previewToken !== void 0 ? { previewToken: context.previewToken } : {},
+    ...context.userToken !== void 0 ? { userToken: context.userToken } : {},
+    ...context.clientId !== void 0 ? { clientId: context.clientId } : {},
+    ...context.clientAgent !== void 0 ? { clientAgent: context.clientAgent } : {},
+    ...typeof config.public.croct.baseEndpointUrl === "string" && config.public.croct.baseEndpointUrl !== "" ? { baseEndpointUrl: config.public.croct.baseEndpointUrl } : {},
+    ...typeof timeout === "number" && timeout > 0 ? { timeout } : {},
+    extra: { cache: "no-store" },
+    logger: FilteredLogger.include(new ConsoleLogger(), ["warn", "error"]),
+    ...options,
+    ...context.uri !== void 0 ? {
+      context: {
+        page: {
+          url: context.uri,
+          ...context.referrer !== void 0 ? { referrer: context.referrer } : {}
+        }
+      }
+    } : {}
+  });
+}

package/dist/runtime/server/composables/fetchContent.d.ts

@@ -0,0 +1,9 @@
+import type { SlotContent, VersionedSlotId } from '@croct/plug/slot';
+import type { JsonObject } from '@croct/plug/sdk/json';
+import type { FetchResponseOptions } from '@croct/sdk/contentFetcher';
+import type { DynamicContentOptions as DynamicOptions, StaticContentOptions as StaticOptions, FetchResponse } from '@croct/plug/api';
+export type DynamicContentOptions<T extends JsonObject = JsonObject> = Omit<DynamicOptions<T>, 'apiKey' | 'appId'>;
+export type StaticContentOptions<T extends JsonObject = JsonObject> = Omit<StaticOptions<T>, 'apiKey' | 'appId'>;
+export type FetchContentOptions<T extends JsonObject = JsonObject> = DynamicContentOptions<T> | StaticContentOptions<T>;
+export type { FetchResponse };
+export declare function fetchContent<I extends VersionedSlotId, C extends JsonObject, O extends FetchResponseOptions = FetchResponseOptions>(slotId: I, options?: Pick<O, keyof FetchResponseOptions> & FetchContentOptions<SlotContent<I, C>>): Promise<FetchResponse<I, C, never, O>>;

package/dist/runtime/server/composables/fetchContent.js

@@ -0,0 +1,50 @@
+import { fetchContent as loadContent } from "@croct/plug/api";
+import { FilteredLogger } from "@croct/sdk/logging/filteredLogger";
+import { ConsoleLogger } from "@croct/sdk/logging/consoleLogger";
+import { useEvent, useRuntimeConfig } from "#imports";
+import { getApiKey } from "../utils/security.js";
+export async function fetchContent(slotId, options = {}) {
+  const event = useEvent();
+  const context = event.context.croct;
+  if (context === void 0) {
+    throw new Error(
+      "Croct's request context is missing. Make sure the @croct/plug-nuxt module is installed in your nuxt.config.ts. For help, see: https://croct.help/sdk/nuxt/missing-middleware"
+    );
+  }
+  const config = useRuntimeConfig();
+  const timeout = config.public.croct.defaultFetchTimeout;
+  const { logger, ...rest } = options;
+  const commonOptions = {
+    apiKey: getApiKey(),
+    ...typeof config.public.croct.baseEndpointUrl === "string" && config.public.croct.baseEndpointUrl !== "" ? { baseEndpointUrl: config.public.croct.baseEndpointUrl } : {},
+    ...typeof timeout === "number" && timeout > 0 ? { timeout } : {},
+    logger: logger ?? FilteredLogger.include(new ConsoleLogger(), ["warn", "error"])
+  };
+  if ("static" in rest && rest.static === true) {
+    const preferredLocale = rest.preferredLocale ?? (config.public.croct.defaultPreferredLocale !== "" ? config.public.croct.defaultPreferredLocale : void 0);
+    return loadContent(slotId, {
+      ...commonOptions,
+      ...rest,
+      ...preferredLocale !== void 0 ? { preferredLocale } : {}
+    });
+  }
+  return loadContent(slotId, {
+    clientIp: context.clientIp,
+    ...context.previewToken !== void 0 ? { previewToken: context.previewToken } : {},
+    ...context.userToken !== void 0 ? { userToken: context.userToken } : {},
+    ...context.clientId !== void 0 ? { clientId: context.clientId } : {},
+    ...context.clientAgent !== void 0 ? { clientAgent: context.clientAgent } : {},
+    ...context.preferredLocale !== void 0 ? { preferredLocale: context.preferredLocale } : {},
+    ...context.uri !== void 0 ? {
+      context: {
+        page: {
+          url: context.uri,
+          ...context.referrer !== void 0 ? { referrer: context.referrer } : {}
+        }
+      }
+    } : {},
+    extra: { cache: "no-store" },
+    ...commonOptions,
+    ...rest
+  });
+}

package/dist/runtime/server/composables/identify.d.ts

@@ -0,0 +1 @@
+export declare function identify(userId: string): Promise<void>;

package/dist/runtime/server/composables/identify.js

@@ -0,0 +1,6 @@
+import { useEvent } from "#imports";
+import { issueToken } from "../utils/security.js";
+import { setUserTokenCookie } from "../utils/cookie.js";
+export async function identify(userId) {
+  setUserTokenCookie(useEvent(), await issueToken(userId));
+}

package/dist/runtime/server/croct-resolvers.d.ts

@@ -0,0 +1,4 @@
+import type {H3Event} from 'h3';
+
+export type UserIdResolver = (event: H3Event) => Promise<string | null> | string | null;
+export type LocaleResolver = (event: H3Event) => Promise<string | null> | string | null;

package/dist/runtime/server/middleware/croct.d.ts

@@ -0,0 +1,2 @@
+declare const _default: globalThis.EventHandler<globalThis.EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/middleware/croct.js

@@ -0,0 +1,138 @@
+import {
+  defineEventHandler,
+  getRequestURL,
+  getHeader,
+  getCookie,
+  setCookie,
+  deleteCookie,
+  getQuery
+} from "h3";
+import { Token } from "@croct/sdk/token";
+import { base64UrlDecode } from "@croct/sdk/base64Url";
+import { useRuntimeConfig } from "#imports";
+import { localeResolver, userIdResolver } from "#croct/resolvers";
+import { setUserTokenCookie, getProductionDefaults } from "../utils/cookie.js";
+import { getAuthenticationKey, isUserTokenAuthenticationEnabled, issueToken } from "../utils/security.js";
+const CLIENT_ID_PATTERN = /^(?:[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}|[a-f0-9]{32})$/;
+const PREVIEW_QUERY_PARAM = "croct-preview";
+const SKIP_EXTENSIONS = /\.(?:js|css|map|ico|png|jpg|jpeg|gif|svg|woff2?|ttf|eot|webp|avif|json|xml|txt)$/;
+const SKIP_PREFIXES = ["/_nuxt/", "/__nuxt_error"];
+function shouldSkip(pathname) {
+  if (SKIP_EXTENSIONS.test(pathname)) {
+    return true;
+  }
+  return SKIP_PREFIXES.some((prefix) => pathname.startsWith(prefix));
+}
+export default defineEventHandler(async (event) => {
+  const url = getRequestURL(event);
+  if (shouldSkip(url.pathname)) {
+    return;
+  }
+  const config = useRuntimeConfig();
+  const { cookie } = config.public.croct;
+  const clientId = resolveClientId(getCookie(event, cookie.clientId.name));
+  const userToken = await resolveUserToken(event, getCookie(event, cookie.userToken.name));
+  const preferredLocale = await resolvePreferredLocale(event, config.public.croct.defaultPreferredLocale);
+  const previewToken = resolvePreviewToken(
+    getQuery(event)[PREVIEW_QUERY_PARAM],
+    getCookie(event, cookie.previewToken.name)
+  );
+  const clientIp = getHeader(event, "x-forwarded-for")?.split(",")[0].trim() ?? getHeader(event, "x-real-ip") ?? void 0;
+  const context = {
+    clientId,
+    userToken: userToken.toString(),
+    uri: stripPreviewParam(url),
+    ...clientIp !== void 0 ? { clientIp } : {},
+    ...preferredLocale !== void 0 ? { preferredLocale } : {},
+    ...previewToken !== null && previewToken !== "exit" ? { previewToken } : {},
+    clientAgent: getHeader(event, "user-agent"),
+    referrer: getHeader(event, "referer")
+  };
+  event.context.croct = context;
+  const productionDefaults = getProductionDefaults();
+  if (previewToken === "exit") {
+    deleteCookie(event, cookie.previewToken.name);
+  } else if (previewToken !== null) {
+    setCookie(event, cookie.previewToken.name, previewToken, {
+      path: "/",
+      ...cookie.previewToken.domain !== "" ? { domain: cookie.previewToken.domain } : {},
+      ...productionDefaults,
+      httpOnly: true
+    });
+  }
+  setUserTokenCookie(event, userToken);
+  setCookie(event, cookie.clientId.name, clientId, {
+    maxAge: cookie.clientId.duration,
+    path: "/",
+    ...cookie.clientId.domain !== "" ? { domain: cookie.clientId.domain } : {},
+    ...productionDefaults,
+    httpOnly: true
+  });
+});
+function resolveClientId(cookieValue) {
+  if (cookieValue !== void 0 && CLIENT_ID_PATTERN.test(cookieValue)) {
+    return cookieValue;
+  }
+  return crypto.randomUUID();
+}
+async function resolveUserToken(event, cookieValue) {
+  const { appId } = useRuntimeConfig().public.croct;
+  let token = null;
+  if (cookieValue !== void 0) {
+    try {
+      token = Token.parse(cookieValue);
+    } catch {
+    }
+  }
+  const userId = userIdResolver !== void 0 ? await userIdResolver(event) : void 0;
+  if (token === null || isUserTokenAuthenticationEnabled() && !token.isSigned() || !token.isValidNow() || userId !== void 0 && (userId === null ? !token.isAnonymous() : !token.isSubject(userId))) {
+    return issueToken(userId ?? null);
+  }
+  const tokenAppId = token.getApplicationId();
+  if (tokenAppId !== null && tokenAppId !== appId) {
+    return issueToken(userId ?? null);
+  }
+  if (token.isSigned() && !await token.matchesKeyId(getAuthenticationKey())) {
+    return issueToken(token.getSubject(), token.getTokenId() ?? void 0);
+  }
+  return token;
+}
+async function resolvePreferredLocale(event, defaultLocale) {
+  if (localeResolver !== void 0) {
+    const locale = await localeResolver(event);
+    if (locale !== null && locale !== "") {
+      return locale;
+    }
+  }
+  if (defaultLocale !== "") {
+    return defaultLocale;
+  }
+  return void 0;
+}
+function resolvePreviewToken(queryParam, cookieValue) {
+  const value = queryParam ?? cookieValue;
+  if (value === void 0) {
+    return null;
+  }
+  if (isPreviewTokenValid(value)) {
+    return value;
+  }
+  return "exit";
+}
+function isPreviewTokenValid(token) {
+  if (typeof token !== "string" || token === "exit") {
+    return false;
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  try {
+    const payload = JSON.parse(base64UrlDecode(token.split(".")[1]).toString());
+    return Number.isInteger(payload.exp) && payload.exp > now;
+  } catch {
+    return false;
+  }
+}
+function stripPreviewParam(url) {
+  const cleaned = new URL(url.toString());
+  cleaned.searchParams.delete(PREVIEW_QUERY_PARAM);
+  return cleaned.toString();
+}

package/dist/runtime/server/utils/cookie.d.ts

@@ -0,0 +1,8 @@
+import type { H3Event } from 'h3';
+import type { Token } from '@croct/sdk/token';
+declare function getProductionDefaults(): {
+    secure?: boolean;
+    sameSite?: 'none';
+};
+export declare function setUserTokenCookie(event: H3Event, token: Token): void;
+export { getProductionDefaults };

package/dist/runtime/server/utils/cookie.js

@@ -0,0 +1,19 @@
+import { setCookie } from "h3";
+import { useRuntimeConfig } from "#imports";
+function getProductionDefaults() {
+  if (process.env.NODE_ENV !== "production") {
+    return {};
+  }
+  return { secure: true, sameSite: "none" };
+}
+export function setUserTokenCookie(event, token) {
+  const config = useRuntimeConfig().public.croct.cookie.userToken;
+  setCookie(event, config.name, token.toString(), {
+    maxAge: config.duration,
+    path: "/",
+    ...config.domain !== "" ? { domain: config.domain } : {},
+    ...getProductionDefaults(),
+    httpOnly: true
+  });
+}
+export { getProductionDefaults };

package/dist/runtime/server/utils/security.d.ts

@@ -0,0 +1,6 @@
+import { ApiKey } from '@croct/sdk/apiKey';
+import { Token } from '@croct/sdk/token';
+export declare function getApiKey(): ApiKey;
+export declare function getAuthenticationKey(): ApiKey;
+export declare function isUserTokenAuthenticationEnabled(): boolean;
+export declare function issueToken(userId?: string | null, tokenId?: string): Promise<Token>;

package/dist/runtime/server/utils/security.js

@@ -0,0 +1,40 @@
+import { ApiKey } from "@croct/sdk/apiKey";
+import { Token } from "@croct/sdk/token";
+import { useRuntimeConfig } from "#imports";
+export function getApiKey() {
+  const { apiKey } = useRuntimeConfig().croct;
+  if (apiKey === "") {
+    throw new Error(
+      "Croct's API key is missing. Did you forget to set the NUXT_CROCT_API_KEY environment variable? For help, see: https://croct.help/sdk/nuxt/missing-environment-variable"
+    );
+  }
+  try {
+    return ApiKey.parse(apiKey);
+  } catch {
+    throw new Error(
+      "Croct's API key is invalid. Please check the NUXT_CROCT_API_KEY environment variable."
+    );
+  }
+}
+export function getAuthenticationKey() {
+  const apiKey = getApiKey();
+  if (!apiKey.hasPrivateKey()) {
+    throw new Error(
+      "Croct's API key does not have a private key. Please generate an API key with authenticate permissions and update the NUXT_CROCT_API_KEY environment variable."
+    );
+  }
+  return apiKey;
+}
+export function isUserTokenAuthenticationEnabled() {
+  const config = useRuntimeConfig().croct;
+  return config.apiKey !== "" && config.disableUserTokenAuthentication !== true;
+}
+export function issueToken(userId = null, tokenId) {
+  const config = useRuntimeConfig();
+  const { appId } = config.public.croct;
+  const token = Token.issue(appId, userId).withDuration(config.croct.tokenDuration);
+  if (isUserTokenAuthenticationEnabled()) {
+    return token.withTokenId(tokenId ?? crypto.randomUUID()).signedWith(getAuthenticationKey());
+  }
+  return Promise.resolve(token);
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,5 @@
+export type * from '@croct/plug/sdk/json';
+export type * from '@croct/plug/slot';
+export type * from '@croct/plug/component';
+export type { UrlSanitizer } from '@croct/sdk/tab';
+export type { UserIdResolver, LocaleResolver } from './server/croct-resolvers.js';

package/dist/runtime/utils/locale.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from 'vue';
+declare module '#app' {
+    interface NuxtApp {
+        $i18n?: {
+            locale: Ref<string>;
+        };
+    }
+}
+export declare function resolveLocale(explicitLocale?: string): string | undefined;

package/dist/runtime/utils/locale.js

@@ -0,0 +1,15 @@
+import { useNuxtApp, useRuntimeConfig } from "#app";
+export function resolveLocale(explicitLocale) {
+  if (explicitLocale !== void 0 && explicitLocale !== "") {
+    return explicitLocale;
+  }
+  const config = useRuntimeConfig().public.croct;
+  if (config.defaultPreferredLocale !== "") {
+    return config.defaultPreferredLocale;
+  }
+  const i18nLocale = useNuxtApp().$i18n?.locale.value;
+  if (i18nLocale !== void 0) {
+    return i18nLocale;
+  }
+  return void 0;
+}

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

@@ -1,6 +1,6 @@
 {
   "name": "@croct/plug-nuxt",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Nuxt module to plug your Nuxt 3 applications into Croct.",
   "author": {
     "name": "Croct",
@@ -40,8 +40,9 @@
     "url": "git+https://github.com/croct-tech/plug-nuxt.git"
   },
   "scripts": {
+    "prepare": "nuxi prepare e2e/app",
+    "prepack": "nuxt-module-build build",
     "dev": "nuxi dev e2e/app",
-    "postinstall": "nuxi prepare e2e/app",
     "dev:build": "nuxi build e2e/app",
     "build": "nuxt-module-build build",
     "lint": "eslint .",