nuxt-directus-sdk 0.0.2

package/README.md

@@ -0,0 +1,84 @@
+# directus-nuxt-sdk
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+> A bunch of directus helpers for nuxt applications
+
+- [✨  Release Notes](/CHANGELOG.md)
+
+## Features
+
+- ⛰  Built-in Directus auth and type generation
+- 🚠  Built-in helpers and utils 
+
+## Quick Setup
+
+1. Add `directus-nuxt-sdk` dependency to your project
+
+```bash
+# Using pnpm
+pnpm add -D directus-nuxt-sdk
+
+# Using yarn
+yarn add --dev directus-nuxt-sdk
+
+# Using npm
+npm install --save-dev directus-nuxt-sdk
+
+# Using bun
+bun install --save-dev directus-nuxt-sdk
+```
+
+2. Add `directus-nuxt-sdk` to the `modules` section of `nuxt.config.ts`
+
+```js
+export default defineNuxtConfig({
+  modules: [
+    'directus-nuxt-sdk'
+  ]
+})
+```
+
+That's it! You can now use Directus your Nuxt app ✨
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Generate type stubs
+npm run dev:prepare
+
+# Develop with the playground
+npm run dev
+
+# Build the playground
+npm run dev:build
+
+# Run ESLint
+npm run lint
+
+# Run Vitest
+npm run test
+npm run test:watch
+
+# Release new version
+npm run release
+```
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/directus-nuxt-sdk/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-version-href]: https://npmjs.com/package/directus-nuxt-sdk
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/directus-nuxt-sdk.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-downloads-href]: https://npmjs.com/package/directus-nuxt-sdk
+
+[license-src]: https://img.shields.io/npm/l/directus-nuxt-sdk.svg?style=flat&colorA=18181B&colorB=28CF8D
+[license-href]: https://npmjs.com/package/directus-nuxt-sdk
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-18181B?logo=nuxt.js
+[nuxt-href]: https://nuxt.com

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,77 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { Query } from '@directus/sdk';
+import { DirectusCollections } from '#build/types/directus';
+
+interface ModuleOptions {
+    /**
+     * Directus API URL
+     * @default process.env.DIRECTUS_URL
+     * @type string
+     */
+    url?: string;
+    /**
+     * Admin Auth Token used for generating types and server functions
+     * @default process.env.DIRECTUS_ADMIN_TOKEN
+     * @type string
+     */
+    adminToken?: string;
+    /**
+     * Fetch the user serverside
+    *
+    * @default true
+    */
+    fetchUser?: boolean;
+    /**
+    * Directus Auth Options
+    * @default {}
+    * @type Query<DirectusCollections, 'directus_users'>
+   */
+    fetchUserParams?: Query<DirectusCollections, 'directus_users'>;
+    /**
+     * Add Directus Admin in Nuxt Devtools
+     *
+     * @default false
+    */
+    devtools?: boolean;
+    /**
+     * Token Cookie Name
+     * @type string
+     * @ default 'directus_token'
+     */
+    cookieNameToken?: string;
+    /**
+       * Refresh Token Cookie Name
+       * @type string
+       * @default 'directus_refresh_token'
+       */
+    cookieNameRefreshToken?: string;
+    /**
+       * The max age for auth cookies in seconds.
+       * This should match your directus env key AUTH_TOKEN_TTL
+       * @type string
+       * @default 900
+       */
+    cookieMaxAge?: number;
+    /**
+       * The max age for auth cookies in seconds.
+       * This should match your directus env key REFRESH_TOKEN_TTL
+       * @type string
+       * @default 604800
+       */
+    cookieMaxAgeRefreshToken?: number;
+    /**
+       * The SameSite attribute for auth cookies.
+       * @type string
+       * @default 'lax'
+       */
+    cookieSameSite?: 'strict' | 'lax' | 'none' | undefined;
+    /**
+       * The Secure attribute for auth cookies.
+       * @type boolean
+       * @default false
+       */
+    cookieSecure?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { type ModuleOptions, _default as default };

package/dist/module.d.ts

@@ -0,0 +1,77 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { Query } from '@directus/sdk';
+import { DirectusCollections } from '#build/types/directus';
+
+interface ModuleOptions {
+    /**
+     * Directus API URL
+     * @default process.env.DIRECTUS_URL
+     * @type string
+     */
+    url?: string;
+    /**
+     * Admin Auth Token used for generating types and server functions
+     * @default process.env.DIRECTUS_ADMIN_TOKEN
+     * @type string
+     */
+    adminToken?: string;
+    /**
+     * Fetch the user serverside
+    *
+    * @default true
+    */
+    fetchUser?: boolean;
+    /**
+    * Directus Auth Options
+    * @default {}
+    * @type Query<DirectusCollections, 'directus_users'>
+   */
+    fetchUserParams?: Query<DirectusCollections, 'directus_users'>;
+    /**
+     * Add Directus Admin in Nuxt Devtools
+     *
+     * @default false
+    */
+    devtools?: boolean;
+    /**
+     * Token Cookie Name
+     * @type string
+     * @ default 'directus_token'
+     */
+    cookieNameToken?: string;
+    /**
+       * Refresh Token Cookie Name
+       * @type string
+       * @default 'directus_refresh_token'
+       */
+    cookieNameRefreshToken?: string;
+    /**
+       * The max age for auth cookies in seconds.
+       * This should match your directus env key AUTH_TOKEN_TTL
+       * @type string
+       * @default 900
+       */
+    cookieMaxAge?: number;
+    /**
+       * The max age for auth cookies in seconds.
+       * This should match your directus env key REFRESH_TOKEN_TTL
+       * @type string
+       * @default 604800
+       */
+    cookieMaxAgeRefreshToken?: number;
+    /**
+       * The SameSite attribute for auth cookies.
+       * @type string
+       * @default 'lax'
+       */
+    cookieSameSite?: 'strict' | 'lax' | 'none' | undefined;
+    /**
+       * The Secure attribute for auth cookies.
+       * @type boolean
+       * @default false
+       */
+    cookieSecure?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { type ModuleOptions, _default as default };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "nuxt-directus-sdk",
+  "version": "0.0.2",
+  "configKey": "rolley",
+  "compatibility": {
+    "nuxt": "^3.0.0",
+    "bridge": false
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,224 @@
+import { defu } from 'defu';
+import { defineNuxtModule, createResolver, addPlugin, addImportsDir, addComponentsDir, addTypeTemplate, logger } from '@nuxt/kit';
+import { joinURL } from 'ufo';
+import { snakeCase } from 'change-case';
+import { createDirectus, authentication, rest, readOpenApiSpec } from '@directus/sdk';
+
+const name = "nuxt-directus-sdk";
+const version = "0.0.2";
+
+function mapPropertyType(propertyType) {
+  return propertyType === "integer" ? "number" : propertyType;
+}
+function processOneOfProperty(schemas, name, property) {
+  const ref = property.oneOf.find((item) => {
+    return "$ref" in item;
+  });
+  if (ref) {
+    const $ref = ref.$ref;
+    const $refKey = $ref.split("/").pop();
+    if ($refKey) {
+      const $refSchema = `DirectusCollections['${schemas[$refKey]?.["x-collection"]}']`;
+      if ($refSchema)
+        return $refSchema;
+    }
+  }
+  const firstValue = property.oneOf?.[0];
+  if ("type" in firstValue) {
+    const firstType = mapPropertyType(firstValue.type);
+    if (firstType)
+      return firstType;
+  }
+  console.error("Unknown schema for oneOf", name, property);
+  return "";
+}
+function processProperty(schemas, name, property) {
+  if ("type" in property) {
+    if (property.type === "array" && property.items) {
+      if (!property.items.oneOf)
+        return processProperty(schemas, name, property.items);
+      return `
+      "${name}": ${processOneOfProperty(schemas, name, property.items)};
+    `;
+    } else {
+      return `
+      ${property.format ? `/* ${property.format} */` : ""}
+      "${name}": ${mapPropertyType(property.type ?? "string")};
+    `;
+    }
+  } else if ("oneOf" in property) {
+    const value = processOneOfProperty(schemas, name, property);
+    if (!value)
+      return;
+    const simpleTypes = ["string", "number", "boolean"];
+    const valueType = simpleTypes.includes(value) ? value : `Single<${value}>`;
+    return `
+      "${name}": ${valueType};
+    `;
+  }
+}
+async function generateTypes(options) {
+  const directus = createDirectus(options.url).with(authentication("json", { autoRefresh: false })).with(rest());
+  directus.setToken(options.token);
+  const data = await directus.request(readOpenApiSpec());
+  const types = [];
+  const schemas = data.components.schemas;
+  const schemaNames = [];
+  Object.entries(schemas).forEach(([_, schema]) => {
+    const schemaName = schema["x-collection"];
+    if (!schemaName)
+      return;
+    if (schema.type !== "object") {
+      console.error(schemaName, "is not an object");
+      return;
+    }
+    if (schemaNames.includes(schemaName))
+      return;
+    schemaNames.push(schemaName);
+    const properties = [];
+    Object.entries(schema.properties).forEach(([name, property]) => {
+      const propertyType = processProperty(schemas, name, property);
+      if (propertyType)
+        properties.push(propertyType.trim());
+    });
+    types.push(`${snakeCase(schemaName)}: {
+      ${properties.join("\n")}
+    }[];
+`);
+  });
+  const exportProperties = types.join("\n");
+  return `
+  export type Single<T extends any[]> = T extends (infer U)[] ? U : never;
+
+  export type DirectusCollections = {
+    ${exportProperties}
+  };
+
+  export type DirectusCollectionUser = Single<DirectusCollections['directus_users']>;
+
+declare global {
+  type Single = Single
+  type DirectusCollections = DirectusCollections
+  type DirectusCollectionUser = DirectusCollectionUser
+}
+
+  export {};
+`;
+}
+
+const configKey = "rolley";
+const module = defineNuxtModule({
+  meta: {
+    name,
+    version,
+    configKey,
+    compatibility: {
+      nuxt: "^3.0.0",
+      bridge: false
+    }
+  },
+  defaults: {
+    url: process.env.DIRECTUS_URL,
+    adminToken: process.env.DIRECTUS_ADMIN_TOKEN,
+    fetchUser: true,
+    devtools: false,
+    cookieNameToken: "directus_token",
+    cookieNameRefreshToken: "directus_refresh_token",
+    // Nuxt Cookies Docs @ https://nuxt.com/docs/api/composables/use-cookie
+    cookieMaxAge: 900,
+    cookieMaxAgeRefreshToken: 604800,
+    cookieSameSite: "lax",
+    cookieSecure: false
+  },
+  async setup(options, nuxt) {
+    nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
+    nuxt.options.runtimeConfig.public[configKey] = defu(nuxt.options.runtimeConfig.public[configKey], {
+      url: options.url,
+      fetchUser: options.fetchUser,
+      fetchUserParams: options.fetchUserParams,
+      devtools: options.devtools,
+      cookieNameToken: options.cookieNameToken,
+      cookieNameRefreshToken: options.cookieNameRefreshToken,
+      cookieMaxAge: options.cookieMaxAge,
+      cookieMaxAgeRefreshToken: options.cookieMaxAgeRefreshToken,
+      cookieSameSite: options.cookieSameSite,
+      cookieSecure: options.cookieSecure
+    });
+    const resolver = createResolver(import.meta.url);
+    addPlugin(resolver.resolve("./runtime/plugin"));
+    addPlugin({
+      src: resolver.resolve("./runtime/plugin.client"),
+      mode: "client"
+    });
+    addImportsDir(resolver.resolve("./runtime/composables"));
+    addComponentsDir({
+      path: resolver.resolve("./runtime/components"),
+      pathPrefix: false,
+      prefix: "",
+      global: true
+    });
+    nuxt.options.css.push("vue-toastification/dist/index.css");
+    nuxt.options.build.transpile.push("vue-toastification");
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.alias = nitroConfig.alias || {};
+      nitroConfig.externals = defu(typeof nitroConfig.externals === "object" ? nitroConfig.externals : {}, {
+        inline: [resolver.resolve("./runtime")]
+      });
+      nitroConfig.alias[`#${configKey}`] = resolver.resolve("./runtime/server/services");
+    });
+    addTypeTemplate({
+      filename: `types/${configKey}.d.ts`,
+      getContents: () => [
+        `declare module '#${configKey}' {`,
+        `  const useDirectus: typeof import('${resolver.resolve("./runtime/server/services")}').useDirectus`,
+        `  const useAdminDirectus: typeof import('${resolver.resolve("./runtime/server/services")}').useAdminDirectus`,
+        `  const useDirectusUrl: typeof import('${resolver.resolve("./runtime/server/services")}').useDirectusUrl`,
+        `  const useDirectusAccessToken: typeof import('${resolver.resolve("./runtime/server/services")}').useDirectusAccessToken`,
+        "}"
+      ].join("\n")
+    });
+    nuxt.hook("prepare:types", (options2) => {
+      options2.references.push({ path: resolver.resolve(nuxt.options.buildDir, `types/${configKey}.d.ts`) });
+    });
+    if (options.url) {
+      const adminUrl = joinURL(options.url, "/admin/");
+      logger.info(`Directus Admin URL: ${adminUrl}`);
+      if (options.devtools) {
+        nuxt.hook("devtools:customTabs", (iframeTabs) => {
+          iframeTabs.push({
+            name: "directus",
+            title: "Directus",
+            icon: "simple-icons:directus",
+            view: {
+              type: "iframe",
+              src: adminUrl
+            }
+          });
+        });
+      }
+      if (options.adminToken) {
+        logger.info("Generating Directus types");
+        try {
+          const typesPath = addTypeTemplate({
+            filename: "types/directus.d.ts",
+            getContents() {
+              return generateTypes({
+                url: options.url ?? "",
+                token: options.adminToken ?? ""
+              });
+            }
+          }).dst;
+          nuxt.hook("prepare:types", (options2) => {
+            options2.references.push({ path: typesPath });
+          });
+        } catch (error) {
+          logger.error(error.message);
+        }
+      } else {
+        logger.info("Add DIRECTUS_ADMIN_TOKEN to the .env file to generate directus types");
+      }
+    }
+  }
+});
+
+export { module as default };

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

@@ -0,0 +1,22 @@
+import type { ComputedRef, Ref } from '#imports';
+import type { DirectusCollectionUser } from '#build/types/directus';
+export declare function useDirectusUser(): Ref<any>;
+export interface DirectusAuth {
+    user: Ref<DirectusCollectionUser | null>;
+    loggedIn: ComputedRef<boolean>;
+    refreshTokens(): Promise<void>;
+    fetchUser(): Promise<DirectusCollectionUser | null>;
+    updateUser(data: Partial<DirectusCollectionUser>): Promise<DirectusCollectionUser | null>;
+    login(email: string, password: string): Promise<{
+        user: DirectusCollectionUser | null;
+        access_token: string;
+        refreshToken: string | null;
+        expires: number;
+        redirect(defaultPath?: string): void;
+    }>;
+    logout(): Promise<void>;
+    register(data: Partial<DirectusCollectionUser>): Promise<DirectusCollectionUser>;
+    requestPasswordReset(email: string, resetUrl?: string | null | undefined): Promise<void>;
+    resetPassword(token: string, password: string): Promise<void>;
+}
+export declare function useDirectusAuth(): DirectusAuth;

package/dist/runtime/composables/auth.mjs

@@ -0,0 +1,83 @@
+import { createUser, passwordRequest, passwordReset, readMe, updateMe } from "@directus/sdk";
+import { useDirectus } from "./directus.mjs";
+import { useDirectusTokens } from "./tokens.mjs";
+import { computed, useState } from "#imports";
+import { useRouter, useRuntimeConfig } from "#app";
+export function useDirectusUser() {
+  return useState("directus.user", () => null);
+}
+export function useDirectusAuth() {
+  const config = useRuntimeConfig();
+  const directus = useDirectus();
+  const tokens = useDirectusTokens();
+  const user = useDirectusUser();
+  const loggedIn = computed(() => user.value !== null);
+  async function fetchUser() {
+    try {
+      if (!tokens.refreshToken.value)
+        throw new Error("No refresh token");
+      await directus.refresh();
+      user.value = await directus.request(readMe(config.public.rolley.fetchUserParams));
+    } catch (e) {
+      user.value = null;
+    }
+    return user.value;
+  }
+  async function updateUser(data) {
+    const currentUser = user.value;
+    if (!currentUser?.id)
+      throw new Error("No user available");
+    user.value = await directus.request(updateMe(data, config.public.rolley.fetchUserParams));
+    return user.value;
+  }
+  async function login(email, password, options = {}) {
+    const response = await directus.login(email, password, options);
+    if (!response.access_token)
+      throw new Error("Login failed, please check your credentials.");
+    await fetchUser();
+    return {
+      user: user.value,
+      accessToken: response.access_token,
+      refreshToken: response.refresh_token,
+      expires: response.expires,
+      expiresAt: response.expires_at,
+      // Allow redirecting to a specific page after login
+      redirect(defaultPath = "/") {
+        const router = useRouter();
+        const route = router.currentRoute.value;
+        router.replace({ path: route.query.redirect ? decodeURIComponent(route.query.redirect) : defaultPath });
+      }
+    };
+  }
+  async function register(data) {
+    return directus.request(createUser(data));
+  }
+  async function requestPasswordReset(email, resetUrl) {
+    directus.request(passwordRequest(email, resetUrl));
+  }
+  async function resetPassword(token, password) {
+    directus.request(passwordReset(token, password));
+  }
+  async function logout() {
+    try {
+      await directus.logout();
+    } finally {
+      user.value = null;
+      tokens.refreshToken.value = null;
+      tokens.accessToken.value = null;
+      tokens.expires.value = null;
+      tokens.expiresAt.value = null;
+    }
+  }
+  return {
+    user,
+    loggedIn,
+    fetchUser,
+    updateUser,
+    register,
+    login,
+    logout,
+    requestPasswordReset,
+    resetPassword
+  };
+}

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

@@ -0,0 +1,2 @@
+export declare function useDirectusUrl(): string;
+export declare function useDirectus(token?: string): import("@directus/sdk/dist/client-e8d6bf91").D<DirectusCollections> & import("@directus/sdk/dist/login-0506af09").d<DirectusCollections> & import("@directus/sdk/dist/login-0506af09").f<DirectusCollections> & import("@directus/sdk/dist/output-35b496cf").d<DirectusCollections>;

package/dist/runtime/composables/directus.mjs

@@ -0,0 +1,35 @@
+import { authentication, createDirectus, realtime, rest } from "@directus/sdk";
+import { useDirectusTokens } from "./tokens.mjs";
+import { useRuntimeConfig } from "#app";
+export function useDirectusUrl() {
+  return useRuntimeConfig().public.rolley.url;
+}
+function createDirectusStorage() {
+  const tokens = useDirectusTokens();
+  return {
+    get() {
+      return {
+        access_token: tokens.accessToken.value,
+        refresh_token: tokens.refreshToken.value,
+        expires: tokens.expires.value,
+        expires_at: tokens.expiresAt.value
+      };
+    },
+    set(value) {
+      tokens.accessToken.value = value?.access_token ?? null;
+      tokens.refreshToken.value = value?.refresh_token ?? null;
+      tokens.expires.value = value?.expires ?? null;
+      tokens.expiresAt.value = value?.expires_at ?? null;
+    }
+  };
+}
+export function useDirectus(token) {
+  const url = useDirectusUrl();
+  const directus = createDirectus(url).with(authentication("json", {
+    storage: createDirectusStorage(),
+    autoRefresh: token !== ""
+  })).with(rest()).with(realtime());
+  if (token)
+    directus.setToken(token);
+  return directus;
+}

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

@@ -0,0 +1,4 @@
+import type { Ref } from '#imports';
+export declare function useDomain(): Ref<string>;
+export declare function useSubdomain(): Ref<string>;
+export declare function getSubdomainLink(slug: string): string;

package/dist/runtime/composables/domain.mjs

@@ -0,0 +1,11 @@
+import { useState } from "#imports";
+export function useDomain() {
+  return useState("domain", () => "");
+}
+export function useSubdomain() {
+  return useState("subdomain", () => "");
+}
+export function getSubdomainLink(slug) {
+  const domain = useDomain();
+  return `//${slug}.${domain.value}/`;
+}

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

@@ -0,0 +1,6 @@
+import type { DirectusThumbnailOptions } from '../types';
+export declare function uploadDirectusFile(file: File, folder?: string): Promise<Record<string, any>>;
+export declare function getDirectusAssetUrl(fileId: string, options?: {
+    token?: string;
+}): string;
+export declare function getDirectusThumbnailUrl(fileId: string, options?: DirectusThumbnailOptions): string;

package/dist/runtime/composables/files.mjs

@@ -0,0 +1,38 @@
+import { uploadFiles } from "@directus/sdk";
+import { useDirectus, useDirectusUrl } from "./directus.mjs";
+export async function uploadDirectusFile(file, folder) {
+  const directus = useDirectus();
+  const formData = new FormData();
+  formData.set("file", file);
+  if (folder)
+    formData.set("folder", folder);
+  return directus.request(uploadFiles(formData));
+}
+export function getDirectusAssetUrl(fileId, options) {
+  const directusUrl = useDirectusUrl();
+  const url = new URL(`${directusUrl}assets/${fileId}`);
+  if (options?.token)
+    url.searchParams.append("access_token", options.token);
+  return url.href;
+}
+export function getDirectusThumbnailUrl(fileId, options) {
+  const directusUrl = useDirectusUrl();
+  const url = new URL(`${directusUrl}assets/${fileId}`);
+  if (options) {
+    if (options.width)
+      url.searchParams.append("width", options.width.toFixed(0));
+    if (options.height)
+      url.searchParams.append("height", options.height.toFixed(0));
+    if (options.quality)
+      url.searchParams.append("quality", options.quality.toFixed(0));
+    if (options.withoutEnlargement)
+      url.searchParams.append("withoutEnlargement", "true");
+    if (options.fit)
+      url.searchParams.append("fit", options.fit);
+    if (options.format)
+      url.searchParams.append("format", options.format);
+    if (options.token)
+      url.searchParams.append("access_token", options.token);
+  }
+  return url.href;
+}

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

@@ -0,0 +1,15 @@
+export declare function useToast(): {
+    log: (message: string) => Promise<void>;
+    success: (message: string, options?: (import("vue-toastification/dist/types/types").ToastOptions & {
+        type?: import("vue-toastification").TYPE.SUCCESS | undefined;
+    }) | undefined) => Promise<void>;
+    info: (message: string, options?: (import("vue-toastification/dist/types/types").ToastOptions & {
+        type?: import("vue-toastification").TYPE.INFO | undefined;
+    }) | undefined) => Promise<void>;
+    warn: (message: string, options?: (import("vue-toastification/dist/types/types").ToastOptions & {
+        type?: import("vue-toastification").TYPE.WARNING | undefined;
+    }) | undefined) => Promise<void>;
+    error: (message?: string, options?: (import("vue-toastification/dist/types/types").ToastOptions & {
+        type?: import("vue-toastification").TYPE.ERROR | undefined;
+    }) | undefined) => Promise<void>;
+};

package/dist/runtime/composables/toast.mjs

@@ -0,0 +1,41 @@
+import { useToast as useToastFn } from "vue-toastification";
+export function useToast() {
+  const toast = useToastFn();
+  async function log(message) {
+    if (process.client)
+      toast(message);
+    else
+      console.log(message);
+  }
+  async function success(message, options) {
+    if (process.client)
+      toast.success(message, options);
+    else
+      console.log("success", message);
+  }
+  async function info(message, options) {
+    if (process.client)
+      toast.info(message, options);
+    else
+      console.info(message);
+  }
+  async function warn(message, options) {
+    if (process.client)
+      toast.warning(message, options);
+    else
+      console.warn(message);
+  }
+  async function error(message = "Something has gone wrong, please try again later.", options) {
+    if (process.client)
+      toast.error(message, options);
+    else
+      console.error(message);
+  }
+  return {
+    log,
+    success,
+    info,
+    warn,
+    error
+  };
+}

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

@@ -0,0 +1,9 @@
+import type { CookieRef } from '#app';
+export declare function getCookieDomain(): string | undefined;
+export interface DirectusTokens {
+    accessToken: CookieRef<string | null>;
+    refreshToken: CookieRef<string | null>;
+    expires: CookieRef<number | null>;
+    expiresAt: CookieRef<number | null>;
+}
+export declare function useDirectusTokens(): DirectusTokens;

package/dist/runtime/composables/tokens.mjs

@@ -0,0 +1,53 @@
+import { useDomain } from "./domain.mjs";
+import { useCookie, useNuxtApp, useRuntimeConfig } from "#app";
+export function getCookieDomain() {
+  const domain = useDomain();
+  return !domain.value.includes("localhost") ? `.${domain.value}` : void 0;
+}
+function directusCookie(name, cookieOptions) {
+  const nuxtApp = useNuxtApp();
+  nuxtApp._cookies = nuxtApp._cookies || {};
+  if (nuxtApp._cookies[name])
+    return nuxtApp._cookies[name];
+  const cookie = useCookie(name, cookieOptions);
+  nuxtApp._cookies[name] = cookie;
+  return cookie;
+}
+export function useDirectusTokens() {
+  const config = useRuntimeConfig().public.rolley;
+  const sharedOptions = {
+    sameSite: config.cookieSameSite,
+    secure: config.cookieSecure,
+    domain: getCookieDomain()
+  };
+  function accessToken() {
+    return directusCookie(config.cookieNameToken, {
+      ...sharedOptions,
+      maxAge: config.cookieMaxAge
+    });
+  }
+  function refreshToken() {
+    return directusCookie(config.cookieNameRefreshToken, {
+      ...sharedOptions,
+      maxAge: config.cookieMaxAgeRefreshToken
+    });
+  }
+  function expires() {
+    return directusCookie("directus_access_expires", {
+      ...sharedOptions,
+      maxAge: config.cookieMaxAge
+    });
+  }
+  function expiresAt() {
+    return directusCookie("directus_access_expires_at", {
+      ...sharedOptions,
+      maxAge: config.cookieMaxAge
+    });
+  }
+  return {
+    accessToken: accessToken(),
+    refreshToken: refreshToken(),
+    expires: expires(),
+    expiresAt: expiresAt()
+  };
+}

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

@@ -0,0 +1,5 @@
+import type { GenerateTypeOptions, SchemaProperty, SchemaPropertyOneOf, SchemaPropertyType, SchemasRecord } from './types';
+export declare function mapPropertyType(propertyType: SchemaPropertyType): "string" | "boolean" | "array" | "number";
+export declare function processOneOfProperty(schemas: SchemasRecord, name: string, property: SchemaPropertyOneOf): string | undefined;
+export declare function processProperty(schemas: SchemasRecord, name: string, property: SchemaProperty): string | undefined;
+export declare function generateTypes(options: GenerateTypeOptions): Promise<string>;

package/dist/runtime/oas/index.mjs

@@ -0,0 +1,100 @@
+import { snakeCase } from "change-case";
+import { authentication, createDirectus, readOpenApiSpec, rest } from "@directus/sdk";
+export function mapPropertyType(propertyType) {
+  return propertyType === "integer" ? "number" : propertyType;
+}
+export function processOneOfProperty(schemas, name, property) {
+  const ref = property.oneOf.find((item) => {
+    return "$ref" in item;
+  });
+  if (ref) {
+    const $ref = ref.$ref;
+    const $refKey = $ref.split("/").pop();
+    if ($refKey) {
+      const $refSchema = `DirectusCollections['${schemas[$refKey]?.["x-collection"]}']`;
+      if ($refSchema)
+        return $refSchema;
+    }
+  }
+  const firstValue = property.oneOf?.[0];
+  if ("type" in firstValue) {
+    const firstType = mapPropertyType(firstValue.type);
+    if (firstType)
+      return firstType;
+  }
+  console.error("Unknown schema for oneOf", name, property);
+  return "";
+}
+export function processProperty(schemas, name, property) {
+  if ("type" in property) {
+    if (property.type === "array" && property.items) {
+      if (!property.items.oneOf)
+        return processProperty(schemas, name, property.items);
+      return `
+      "${name}": ${processOneOfProperty(schemas, name, property.items)};
+    `;
+    } else {
+      return `
+      ${property.format ? `/* ${property.format} */` : ""}
+      "${name}": ${mapPropertyType(property.type ?? "string")};
+    `;
+    }
+  } else if ("oneOf" in property) {
+    const value = processOneOfProperty(schemas, name, property);
+    if (!value)
+      return;
+    const simpleTypes = ["string", "number", "boolean"];
+    const valueType = simpleTypes.includes(value) ? value : `Single<${value}>`;
+    return `
+      "${name}": ${valueType};
+    `;
+  }
+}
+export async function generateTypes(options) {
+  const directus = createDirectus(options.url).with(authentication("json", { autoRefresh: false })).with(rest());
+  directus.setToken(options.token);
+  const data = await directus.request(readOpenApiSpec());
+  const types = [];
+  const schemas = data.components.schemas;
+  const schemaNames = [];
+  Object.entries(schemas).forEach(([_, schema]) => {
+    const schemaName = schema["x-collection"];
+    if (!schemaName)
+      return;
+    if (schema.type !== "object") {
+      console.error(schemaName, "is not an object");
+      return;
+    }
+    if (schemaNames.includes(schemaName))
+      return;
+    schemaNames.push(schemaName);
+    const properties = [];
+    Object.entries(schema.properties).forEach(([name, property]) => {
+      const propertyType = processProperty(schemas, name, property);
+      if (propertyType)
+        properties.push(propertyType.trim());
+    });
+    types.push(`${snakeCase(schemaName)}: {
+      ${properties.join("\n")}
+    }[];
+`);
+  });
+  const exportProperties = types.join("\n");
+  return `
+  export type Single<T extends any[]> = T extends (infer U)[] ? U : never;
+
+  export type DirectusCollections = {
+    ${exportProperties}
+  };
+
+  export type DirectusCollectionUser = Single<DirectusCollections['directus_users']>;
+
+declare global {
+  type Single = Single
+  type DirectusCollections = DirectusCollections
+  type DirectusCollectionUser = DirectusCollectionUser
+}
+
+  export {};
+`;
+}

package/dist/runtime/oas/types.d.ts

@@ -0,0 +1,27 @@
+export interface GenerateTypeOptions {
+    url: string;
+    token: string;
+    collections?: string[];
+}
+export type SchemaPropertyType = 'string' | 'integer' | 'boolean' | 'array';
+export interface SchemaPropertyOneOfReference {
+    $ref: string;
+}
+export type SchemaPropertyOneOfValue = SchemaPropertyOneOfReference | SchemaPropertySingle[];
+export interface SchemaPropertyOneOf {
+    nullable: boolean;
+    oneOf: SchemaPropertyOneOfValue[];
+}
+export interface SchemaPropertySingle {
+    nullable: boolean;
+    type?: SchemaPropertyType;
+    format?: string;
+    items?: SchemaPropertyOneOf;
+}
+export type SchemaProperty = SchemaPropertySingle | SchemaPropertyOneOf;
+export interface Schema {
+    type: string;
+    'x-collection'?: string;
+    properties: Record<string, SchemaProperty>;
+}
+export type SchemasRecord = Record<string, Schema>;

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugin.client.mjs

@@ -0,0 +1,8 @@
+import Toast, { POSITION } from "vue-toastification";
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin(async (nuxt) => {
+  const options = {
+    position: POSITION.BOTTOM_RIGHT
+  };
+  nuxt.vueApp.use(Toast, options);
+});

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugin.mjs

@@ -0,0 +1,35 @@
+import { fromUrl, parseDomain } from "parse-domain";
+import { useDomain, useSubdomain } from "./composables/domain.mjs";
+import { useDirectusAuth } from "./composables/auth.mjs";
+import { addRouteMiddleware, defineNuxtPlugin, navigateTo, useRuntimeConfig } from "#app";
+export default defineNuxtPlugin(async (nuxt) => {
+  const domain = useDomain();
+  const subdomain = useSubdomain();
+  if (nuxt.ssrContext) {
+    const { host } = nuxt.ssrContext.event.node.req.headers;
+    if (host) {
+      const { labels, domain: mainDomain, topLevelDomains } = parseDomain(
+        fromUrl(host)
+      );
+      if (mainDomain)
+        domain.value = `${mainDomain}.${topLevelDomains.join(".")}`;
+      else if (host.includes("localhost"))
+        domain.value = host.split(".").at(-1) ?? "";
+      else
+        domain.value = host;
+      subdomain.value = labels[0];
+    }
+  }
+  const config = useRuntimeConfig();
+  if (config.public.rolley.fetchUser)
+    await useDirectusAuth().fetchUser();
+  addRouteMiddleware("auth", async (to) => {
+    const user = useDirectusAuth().user;
+    if (!user.value) {
+      return navigateTo({
+        path: "/login",
+        query: { redirect: to.path !== "/" ? encodeURIComponent(to.path) : void 0 }
+      });
+    }
+  });
+});

package/dist/runtime/server/services/directus.d.ts

@@ -0,0 +1,5 @@
+import type { H3Event } from 'h3';
+export declare function useDirectusAccessToken(event: H3Event): string | undefined;
+export declare function useDirectusUrl(): string;
+export declare function useDirectus(token?: string): import("@directus/sdk/dist/client-e8d6bf91").D<DirectusCollections> & import("@directus/sdk/dist/login-0506af09").d<DirectusCollections> & import("@directus/sdk/dist/login-0506af09").f<DirectusCollections>;
+export declare function useAdminDirectus(): import("@directus/sdk/dist/client-e8d6bf91").D<DirectusCollections> & import("@directus/sdk/dist/login-0506af09").d<DirectusCollections> & import("@directus/sdk/dist/login-0506af09").f<DirectusCollections>;

package/dist/runtime/server/services/directus.mjs

@@ -0,0 +1,28 @@
+import { authentication, createDirectus, rest } from "@directus/sdk";
+import { getCookie } from "h3";
+import { useRuntimeConfig } from "#imports";
+export function useDirectusAccessToken(event) {
+  return getCookie(event, "directus_access_token");
+}
+export function useDirectusUrl() {
+  return useRuntimeConfig().public.rolley.url;
+}
+export function useDirectus(token) {
+  const url = useDirectusUrl();
+  if (!url)
+    throw new Error("DIRECTUS_URL is not set in config options or .env file");
+  const directus = createDirectus(url).with(authentication("json", { autoRefresh: false })).with(rest());
+  if (token)
+    directus.setToken(token);
+  return directus;
+}
+export function useAdminDirectus() {
+  const url = useDirectusUrl();
+  if (!url)
+    throw new Error("DIRECTUS_URL is not set in config options or .env file");
+  if (!process.env.DIRECTUS_ADMIN_TOKEN)
+    throw new Error("DIRECTUS_ADMIN_TOKEN is not set in config options or .env file");
+  const directus = createDirectus(url).with(authentication("json", { autoRefresh: false })).with(rest());
+  directus.setToken(process.env.DIRECTUS_ADMIN_TOKEN);
+  return directus;
+}

package/dist/runtime/server/services/index.d.ts

@@ -0,0 +1 @@
+export { useDirectusUrl, useDirectus, useAdminDirectus, useDirectusAccessToken } from './directus';

package/dist/runtime/server/services/index.mjs

@@ -0,0 +1 @@
+export { useDirectusUrl, useDirectus, useAdminDirectus, useDirectusAccessToken } from "./directus.mjs";

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

@@ -0,0 +1,38 @@
+export type DirectusThumbnailFormat = 'jpg' | 'png' | 'webp' | 'tiff'
+export type DirectusThumbnailFit = 'cover' | 'contain' | 'inside' | 'outside'
+
+export interface DirectusThumbnailOptions {
+  width?: number
+  height?: number
+  quality?: number
+  fit?: DirectusThumbnailFit
+  format?: DirectusThumbnailFormat
+  withoutEnlargement?: boolean
+  token?: string
+}
+
+export interface DirectusNotificationObject {
+  id?: number
+  timestamp?: string
+  status?: 'inbox' | 'archived'
+  recipient: Array<string> | string
+  sender?: Array<string> | string
+  subject: string
+  message?: string
+  collection?: string
+  item?: string
+}
+
+export interface DirectusQueryParams {
+  fields?: Array<string>
+  sort?: string | Array<string>
+  filter?: Record<string, unknown>
+  limit?: number
+  offset?: number
+  page?: number
+  alias?: string | Array<string>
+  deep?: Record<string, unknown>
+  search?: string
+  meta?: 'total_count' | 'filter_count' | '*'
+}
+

package/dist/types.d.mts

@@ -0,0 +1,15 @@
+
+import { ModuleOptions } from './module'
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig { ['rolley']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['rolley']?: ModuleOptions }
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig { ['rolley']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['rolley']?: ModuleOptions }
+}
+
+
+export { ModuleOptions, default } from './module'

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+
+import { ModuleOptions } from './module'
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig { ['rolley']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['rolley']?: ModuleOptions }
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig { ['rolley']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['rolley']?: ModuleOptions }
+}
+
+
+export { ModuleOptions, default } from './module'

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "nuxt-directus-sdk",
+  "type": "module",
+  "version": "0.0.2",
+  "description": "A nuxt module that uses the directus SDK",
+  "author": "Matthew Rollinson <matt@rolley.io>",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
+    "release": "npm run lint && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "@directus/sdk": "^11.0.3",
+    "@nuxt/kit": "^3.7.1",
+    "change-case": "^4.1.2",
+    "defu": "^6.1.1",
+    "parse-domain": "^7.0.1",
+    "tippy.js": "^6.3.7",
+    "ufo": "^1.1.1",
+    "vue-toastification": "2.0.0-rc.5"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "latest",
+    "@nuxt/eslint-config": "^0.2.0",
+    "@nuxt/module-builder": "^0.5.1",
+    "@nuxt/schema": "^3.7.1",
+    "@nuxt/test-utils": "^3.7.1",
+    "@types/node": "^18.17.14",
+    "changelogen": "^0.5.5",
+    "nuxt": "^3.7.1",
+    "vitest": "^0.34.2"
+  },
+  "unbuild": {
+    "failOnWarn": false
+  }
+}