nuxt-directus-sdk 0.0.2 → 0.0.3

package/README.md

@@ -1,4 +1,4 @@
-# directus-nuxt-sdk
+# nuxt-directus-sdk
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
@@ -16,28 +16,28 @@
 
 ## Quick Setup
 
-1. Add `directus-nuxt-sdk` dependency to your project
+1. Add `nuxt-directus-sdk` dependency to your project
 
 ```bash
 # Using pnpm
-pnpm add -D directus-nuxt-sdk
+pnpm add -D nuxt-directus-sdk
 
 # Using yarn
-yarn add --dev directus-nuxt-sdk
+yarn add --dev nuxt-directus-sdk
 
 # Using npm
-npm install --save-dev directus-nuxt-sdk
+npm install --save-dev nuxt-directus-sdk
 
 # Using bun
-bun install --save-dev directus-nuxt-sdk
+bun install --save-dev nuxt-directus-sdk
 ```
 
-2. Add `directus-nuxt-sdk` to the `modules` section of `nuxt.config.ts`
+2. Add `nuxt-directus-sdk` to the `modules` section of `nuxt.config.ts`
 
 ```js
 export default defineNuxtConfig({
   modules: [
-    'directus-nuxt-sdk'
+    'nuxt-directus-sdk'
   ]
 })
 ```
@@ -71,14 +71,14 @@ 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-version-src]: https://img.shields.io/npm/v/nuxt-directus-sdk/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-version-href]: https://npmjs.com/package/nuxt-directus-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
+[npm-downloads-src]: https://img.shields.io/npm/dm/nuxt-directus-sdk.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-downloads-href]: https://npmjs.com/package/nuxt-directus-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
+[license-src]: https://img.shields.io/npm/l/nuxt-directus-sdk.svg?style=flat&colorA=18181B&colorB=28CF8D
+[license-href]: https://npmjs.com/package/nuxt-directus-sdk
 
 [nuxt-src]: https://img.shields.io/badge/Nuxt-18181B?logo=nuxt.js
 [nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -1,6 +1,6 @@
 import * as _nuxt_schema from '@nuxt/schema';
 import { Query } from '@directus/sdk';
-import { DirectusCollections } from '#build/types/directus';
+import { AllCollections } from '#build/types/directus';
 
 interface ModuleOptions {
     /**
@@ -24,9 +24,9 @@ interface ModuleOptions {
     /**
     * Directus Auth Options
     * @default {}
-    * @type Query<DirectusCollections, 'directus_users'>
+    * @type Query<AllCollections, AllCollections['directus_users']>
    */
-    fetchUserParams?: Query<DirectusCollections, 'directus_users'>;
+    fetchUserParams?: Query<AllCollections, AllCollections['directus_users']>;
     /**
      * Add Directus Admin in Nuxt Devtools
      *
@@ -36,9 +36,9 @@ interface ModuleOptions {
     /**
      * Token Cookie Name
      * @type string
-     * @ default 'directus_token'
+     * @default 'directus_access_token'
      */
-    cookieNameToken?: string;
+    cookieNameAccessToken?: string;
     /**
        * Refresh Token Cookie Name
        * @type string

package/dist/module.d.ts

@@ -1,6 +1,6 @@
 import * as _nuxt_schema from '@nuxt/schema';
 import { Query } from '@directus/sdk';
-import { DirectusCollections } from '#build/types/directus';
+import { AllCollections } from '#build/types/directus';
 
 interface ModuleOptions {
     /**
@@ -24,9 +24,9 @@ interface ModuleOptions {
     /**
     * Directus Auth Options
     * @default {}
-    * @type Query<DirectusCollections, 'directus_users'>
+    * @type Query<AllCollections, AllCollections['directus_users']>
    */
-    fetchUserParams?: Query<DirectusCollections, 'directus_users'>;
+    fetchUserParams?: Query<AllCollections, AllCollections['directus_users']>;
     /**
      * Add Directus Admin in Nuxt Devtools
      *
@@ -36,9 +36,9 @@ interface ModuleOptions {
     /**
      * Token Cookie Name
      * @type string
-     * @ default 'directus_token'
+     * @default 'directus_access_token'
      */
-    cookieNameToken?: string;
+    cookieNameAccessToken?: string;
     /**
        * Refresh Token Cookie Name
        * @type string

package/dist/module.json

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

package/dist/module.mjs

@@ -1,112 +1,135 @@
 import { defu } from 'defu';
-import { defineNuxtModule, createResolver, addPlugin, addImportsDir, addComponentsDir, addTypeTemplate, logger } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addPlugin, addImportsDir, addComponentsDir, addTypeTemplate } from '@nuxt/kit';
 import { joinURL } from 'ufo';
-import { snakeCase } from 'change-case';
-import { createDirectus, authentication, rest, readOpenApiSpec } from '@directus/sdk';
+import { createDirectus, authentication, rest, readCollections, readFields, readRelations } from '@directus/sdk';
 
 const name = "nuxt-directus-sdk";
-const version = "0.0.2";
+const version = "0.0.3";
 
-function mapPropertyType(propertyType) {
-  return propertyType === "integer" ? "number" : propertyType;
+function warn(message) {
+  useLogger(message);
 }
-function processOneOfProperty(schemas, name, property) {
-  const ref = property.oneOf.find((item) => {
-    return "$ref" in item;
+async function generateTypes(options) {
+  const collections = await getCollections(options);
+  let typeValues = "";
+  const types = [];
+  Object.values(collections).forEach((collection) => {
+    const collectionName = collection.collection;
+    const typeName = pascalCase(collectionName);
+    types.push(`${collectionName}: ${typeName}[]`);
+    typeValues += `export type ${typeName} = {
+`;
+    collection.fields.forEach((field) => {
+      if (field.meta?.interface?.startsWith("presentation-"))
+        return;
+      typeValues += "  ";
+      typeValues += field.field.includes("-") ? `"${field.field}"` : field.field;
+      if (field.schema?.is_nullable)
+        typeValues += "?";
+      typeValues += ": ";
+      typeValues += getType(field);
+      typeValues += ";\n";
+    });
+    typeValues += "};\n\n";
   });
-  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 "";
+  typeValues += `export interface AllCollections {
+${types.map((x) => `  ${x};`).join("\n")}
+};
+
+     interface UsersCollections {
+${types.filter((item) => !item.startsWith("directus_")).map((x) => `  ${x};`).join("\n")}
+};
+
+     declare global {
+      interface DirectusCollections {
+${types.filter((item) => !item.startsWith("directus_")).map((x) => `  ${x};`).join("\n")}
+};
+    }     
+`;
+  typeValues += "\n";
+  return typeValues;
 }
-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};
-    `;
+function pascalCase(str) {
+  return str.split(" ").flatMap((x) => x.split("_")).flatMap((y) => y.split("-")).map((x) => x.charAt(0).toUpperCase() + x.slice(1)).join("");
+}
+function getType(field) {
+  let type = "";
+  if (field.relation && field.relation.type === "many") {
+    type = "any[]";
+  } else if (field.relation) {
+    type += field.relation.collection ? pascalCase(field.relation.collection) : "any";
+    if (field.relation.type === "many")
+      type += "[]";
+  } else {
+    if (["integer", "bigInteger", "float", "decimal"].includes(field.type))
+      type = "number";
+    else if (["boolean"].includes(field.type))
+      type = "boolean";
+    else if (["json", "csv"].includes(field.type))
+      type = "unknown";
+    else
+      type = "string";
   }
+  if (field.schema?.is_nullable) {
+    if (field.relation)
+      type = `${type} | null`;
+    else
+      type += " | null";
+  }
+  return type;
 }
-async function generateTypes(options) {
+async function getCollections(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)
+  const rawCollections = await directus.request(readCollections());
+  const collections = {};
+  rawCollections.sort((a, b) => a.collection.localeCompare(b.collection)).forEach(
+    (collection) => collections[collection.collection] = { ...collection, fields: [] }
+  );
+  const fields = await directus.request(readFields());
+  fields.sort((a, b) => a.field.localeCompare(b.field)).forEach((field) => {
+    if (!collections[field.collection]) {
+      warn(`${field.collection} not found`);
       return;
-    if (schema.type !== "object") {
-      console.error(schemaName, "is not an object");
+    }
+    collections[field.collection].fields.push(field);
+    if (collections[field.collection].fields.length === 0)
+      delete collections[field.collection];
+  });
+  const relations = await directus.request(readRelations());
+  relations.forEach((relation) => {
+    if (!relation.meta) {
+      warn(`Relation on field '${relation.field}' in collection '${relation.collection}' has no meta. Maybe missing a relation inside directus_relations table.`);
       return;
     }
-    if (schemaNames.includes(schemaName))
+    if (!relation.meta.one_collection) {
+      warn("No one collection");
       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 oneField = collections[relation.meta.one_collection]?.fields.find(
+      (field) => field.field === relation.meta.one_field
+    );
+    const manyField = collections[relation.meta.many_collection]?.fields.find(
+      (field) => field.field === relation.meta.many_field
+    );
+    if (oneField) {
+      oneField.relation = {
+        type: "many",
+        collection: relation.meta.many_collection
+      };
+    }
+    if (manyField) {
+      manyField.relation = {
+        type: "one",
+        collection: relation.meta.one_collection
+      };
+    }
   });
-  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
+  return collections;
 }
 
-  export {};
-`;
-}
-
-const configKey = "rolley";
+const configKey = "directus";
+const logger = useLogger("nuxt-directus-sdk");
 const module = defineNuxtModule({
   meta: {
     name,
@@ -120,9 +143,10 @@ const module = defineNuxtModule({
   defaults: {
     url: process.env.DIRECTUS_URL,
     adminToken: process.env.DIRECTUS_ADMIN_TOKEN,
-    fetchUser: true,
     devtools: false,
-    cookieNameToken: "directus_token",
+    fetchUser: true,
+    fetchUserParams: {},
+    cookieNameAccessToken: "directus_access_token",
     cookieNameRefreshToken: "directus_refresh_token",
     // Nuxt Cookies Docs @ https://nuxt.com/docs/api/composables/use-cookie
     cookieMaxAge: 900,
@@ -131,13 +155,14 @@ const module = defineNuxtModule({
     cookieSecure: false
   },
   async setup(options, nuxt) {
+    nuxt.options.runtimeConfig[configKey] = { adminToken: options.adminToken ?? "" };
     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,
+      cookieNameAccessToken: options.cookieNameAccessToken,
       cookieNameRefreshToken: options.cookieNameRefreshToken,
       cookieMaxAge: options.cookieMaxAge,
       cookieMaxAgeRefreshToken: options.cookieMaxAgeRefreshToken,
@@ -166,20 +191,24 @@ const module = defineNuxtModule({
       });
       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`) });
-    });
+    try {
+      const typesPath = addTypeTemplate({
+        filename: `types/${configKey}-server.d.ts`,
+        getContents: () => [
+          `declare module '#${configKey}-server' {`,
+          `  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")
+      }).dst;
+      nuxt.hook("prepare:types", (options2) => {
+        options2.references.push({ path: typesPath });
+      });
+    } catch (error) {
+      logger.error(error.message);
+    }
     if (options.url) {
       const adminUrl = joinURL(options.url, "/admin/");
       logger.info(`Directus Admin URL: ${adminUrl}`);
@@ -200,11 +229,11 @@ const module = defineNuxtModule({
         logger.info("Generating Directus types");
         try {
           const typesPath = addTypeTemplate({
-            filename: "types/directus.d.ts",
+            filename: `types/${configKey}.d.ts`,
             getContents() {
               return generateTypes({
-                url: options.url ?? "",
-                token: options.adminToken ?? ""
+                url: options.url,
+                token: options.adminToken
               });
             }
           }).dst;

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

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

package/dist/runtime/composables/auth.mjs

@@ -17,7 +17,7 @@ export function useDirectusAuth() {
       if (!tokens.refreshToken.value)
         throw new Error("No refresh token");
       await directus.refresh();
-      user.value = await directus.request(readMe(config.public.rolley.fetchUserParams));
+      user.value = await directus.request(readMe(config.public.directus.fetchUserParams));
     } catch (e) {
       user.value = null;
     }
@@ -27,7 +27,7 @@ export function useDirectusAuth() {
     const currentUser = user.value;
     if (!currentUser?.id)
       throw new Error("No user available");
-    user.value = await directus.request(updateMe(data, config.public.rolley.fetchUserParams));
+    user.value = await directus.request(updateMe(data, config.public.directus.fetchUserParams));
     return user.value;
   }
   async function login(email, password, options = {}) {

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

@@ -1,2 +1,4 @@
+import type { AuthenticationClient, DirectusClient, RestClient, WebSocketClient } from '@directus/sdk';
+import type { UsersCollections } from '#build/types/directus';
 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>;
+export declare function useDirectus(token?: string): DirectusClient<UsersCollections> & AuthenticationClient<UsersCollections> & RestClient<UsersCollections> & WebSocketClient<UsersCollections>;

package/dist/runtime/composables/directus.mjs

@@ -2,7 +2,7 @@ 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;
+  return useRuntimeConfig().public.directus.url;
 }
 function createDirectusStorage() {
   const tokens = useDirectusTokens();

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

@@ -1,6 +1,23 @@
-import type { DirectusThumbnailOptions } from '../types';
-export declare function uploadDirectusFile(file: File, folder?: string): Promise<Record<string, any>>;
+import type { Query } from '@directus/sdk';
+import type { AllCollections, DirectusFiles } from '#build/types/directus';
+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;
+}
+interface FileUpload {
+    file: File;
+    data?: Record<keyof DirectusFiles, string>;
+}
+export declare function uploadDirectusFile(files: FileUpload[], query: Query<AllCollections, AllCollections['directus_files']>): Promise<DirectusFiles[]>;
 export declare function getDirectusAssetUrl(fileId: string, options?: {
     token?: string;
 }): string;
 export declare function getDirectusThumbnailUrl(fileId: string, options?: DirectusThumbnailOptions): string;
+export {};

package/dist/runtime/composables/files.mjs

@@ -1,12 +1,17 @@
 import { uploadFiles } from "@directus/sdk";
 import { useDirectus, useDirectusUrl } from "./directus.mjs";
-export async function uploadDirectusFile(file, folder) {
+export async function uploadDirectusFile(files, query) {
   const directus = useDirectus();
   const formData = new FormData();
-  formData.set("file", file);
-  if (folder)
-    formData.set("folder", folder);
-  return directus.request(uploadFiles(formData));
+  files.forEach(({ file, data }, i) => {
+    if (data) {
+      Object.entries(data).forEach(([key, value]) => {
+        formData.set(`file_${i + 1}_${key}`, value);
+      });
+    }
+    formData.set("file", file);
+  });
+  return await directus.request(uploadFiles(formData, query));
 }
 export function getDirectusAssetUrl(fileId, options) {
   const directusUrl = useDirectusUrl();

package/dist/runtime/composables/tokens.mjs

@@ -14,14 +14,14 @@ function directusCookie(name, cookieOptions) {
   return cookie;
 }
 export function useDirectusTokens() {
-  const config = useRuntimeConfig().public.rolley;
+  const config = useRuntimeConfig().public.directus;
   const sharedOptions = {
     sameSite: config.cookieSameSite,
     secure: config.cookieSecure,
     domain: getCookieDomain()
   };
   function accessToken() {
-    return directusCookie(config.cookieNameToken, {
+    return directusCookie(config.cookieNameAccessToken, {
       ...sharedOptions,
       maxAge: config.cookieMaxAge
     });

package/dist/runtime/plugin.mjs

@@ -21,7 +21,7 @@ export default defineNuxtPlugin(async (nuxt) => {
     }
   }
   const config = useRuntimeConfig();
-  if (config.public.rolley.fetchUser)
+  if (config.public.directus.fetchUser)
     await useDirectusAuth().fetchUser();
   addRouteMiddleware("auth", async (to) => {
     const user = useDirectusAuth().user;

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

@@ -1,5 +1,7 @@
+import type { AuthenticationClient, DirectusClient, RestClient } from '@directus/sdk';
 import type { H3Event } from 'h3';
+import type { UsersCollections } from '#build/types/directus';
 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>;
+export declare function useDirectus(token?: string): DirectusClient<UsersCollections> & AuthenticationClient<UsersCollections> & RestClient<UsersCollections>;
+export declare function useAdminDirectus(): DirectusClient<UsersCollections> & AuthenticationClient<UsersCollections> & RestClient<UsersCollections>;

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

@@ -2,10 +2,10 @@ 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");
+  return getCookie(event, useRuntimeConfig().public.directus.cookieNameAccessToken);
 }
 export function useDirectusUrl() {
-  return useRuntimeConfig().public.rolley.url;
+  return useRuntimeConfig().public.directus.url;
 }
 export function useDirectus(token) {
   const url = useDirectusUrl();
@@ -17,12 +17,8 @@ export function useDirectus(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)
+  const config = useRuntimeConfig().directus;
+  if (!config.adminToken)
     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;
+  return useDirectus(config.adminToken);
 }

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

@@ -0,0 +1,7 @@
+import type { Collections } from './generate.types';
+export interface OASOptions {
+    url: string;
+    token: string;
+}
+export declare function generateTypes(options: OASOptions): Promise<string>;
+export declare function getCollections(options: OASOptions): Promise<Collections>;

package/dist/runtime/types/generate.mjs

@@ -0,0 +1,123 @@
+import { useLogger } from "@nuxt/kit";
+import { authentication, createDirectus, readCollections, readFields, readRelations, rest } from "@directus/sdk";
+function warn(message) {
+  useLogger(message);
+}
+export async function generateTypes(options) {
+  const collections = await getCollections(options);
+  let typeValues = "";
+  const types = [];
+  Object.values(collections).forEach((collection) => {
+    const collectionName = collection.collection;
+    const typeName = pascalCase(collectionName);
+    types.push(`${collectionName}: ${typeName}[]`);
+    typeValues += `export type ${typeName} = {
+`;
+    collection.fields.forEach((field) => {
+      if (field.meta?.interface?.startsWith("presentation-"))
+        return;
+      typeValues += "  ";
+      typeValues += field.field.includes("-") ? `"${field.field}"` : field.field;
+      if (field.schema?.is_nullable)
+        typeValues += "?";
+      typeValues += ": ";
+      typeValues += getType(field);
+      typeValues += ";\n";
+    });
+    typeValues += "};\n\n";
+  });
+  typeValues += `export interface AllCollections {
+${types.map((x) => `  ${x};`).join("\n")}
+};
+
+     interface UsersCollections {
+${types.filter((item) => !item.startsWith("directus_")).map((x) => `  ${x};`).join("\n")}
+};
+
+     declare global {
+      interface DirectusCollections {
+${types.filter((item) => !item.startsWith("directus_")).map((x) => `  ${x};`).join("\n")}
+};
+    }     
+`;
+  typeValues += "\n";
+  return typeValues;
+}
+function pascalCase(str) {
+  return str.split(" ").flatMap((x) => x.split("_")).flatMap((y) => y.split("-")).map((x) => x.charAt(0).toUpperCase() + x.slice(1)).join("");
+}
+function getType(field) {
+  let type = "";
+  if (field.relation && field.relation.type === "many") {
+    type = "any[]";
+  } else if (field.relation) {
+    type += field.relation.collection ? pascalCase(field.relation.collection) : "any";
+    if (field.relation.type === "many")
+      type += "[]";
+  } else {
+    if (["integer", "bigInteger", "float", "decimal"].includes(field.type))
+      type = "number";
+    else if (["boolean"].includes(field.type))
+      type = "boolean";
+    else if (["json", "csv"].includes(field.type))
+      type = "unknown";
+    else
+      type = "string";
+  }
+  if (field.schema?.is_nullable) {
+    if (field.relation)
+      type = `${type} | null`;
+    else
+      type += " | null";
+  }
+  return type;
+}
+export async function getCollections(options) {
+  const directus = createDirectus(options.url).with(authentication("json", { autoRefresh: false })).with(rest());
+  directus.setToken(options.token);
+  const rawCollections = await directus.request(readCollections());
+  const collections = {};
+  rawCollections.sort((a, b) => a.collection.localeCompare(b.collection)).forEach(
+    (collection) => collections[collection.collection] = { ...collection, fields: [] }
+  );
+  const fields = await directus.request(readFields());
+  fields.sort((a, b) => a.field.localeCompare(b.field)).forEach((field) => {
+    if (!collections[field.collection]) {
+      warn(`${field.collection} not found`);
+      return;
+    }
+    collections[field.collection].fields.push(field);
+    if (collections[field.collection].fields.length === 0)
+      delete collections[field.collection];
+  });
+  const relations = await directus.request(readRelations());
+  relations.forEach((relation) => {
+    if (!relation.meta) {
+      warn(`Relation on field '${relation.field}' in collection '${relation.collection}' has no meta. Maybe missing a relation inside directus_relations table.`);
+      return;
+    }
+    if (!relation.meta.one_collection) {
+      warn("No one collection");
+      return;
+    }
+    const oneField = collections[relation.meta.one_collection]?.fields.find(
+      (field) => field.field === relation.meta.one_field
+    );
+    const manyField = collections[relation.meta.many_collection]?.fields.find(
+      (field) => field.field === relation.meta.many_field
+    );
+    if (oneField) {
+      oneField.relation = {
+        type: "many",
+        collection: relation.meta.many_collection
+      };
+    }
+    if (manyField) {
+      manyField.relation = {
+        type: "one",
+        collection: relation.meta.one_collection
+      };
+    }
+  });
+  return collections;
+}

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

@@ -0,0 +1,13 @@
+import type { Collection as DirectusCollection, Field as DirectusField } from '@directus/shared/types';
+export type Field = DirectusField & {
+    relation?: {
+        type: 'many' | 'one';
+        collection: string;
+    };
+};
+export type Collection = DirectusCollection & {
+    fields: Field[];
+};
+export interface Collections {
+    [collection: string]: Collection;
+}

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

@@ -1,38 +1 @@
-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' | '*'
-}
-
+export { generateTypes } from './generate';

package/dist/runtime/types/index.mjs

@@ -0,0 +1 @@
+export { generateTypes } from "./generate.mjs";

package/dist/types.d.mts

@@ -2,13 +2,13 @@
 import { ModuleOptions } from './module'
 
 declare module '@nuxt/schema' {
-  interface NuxtConfig { ['rolley']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['rolley']?: ModuleOptions }
+  interface NuxtConfig { ['directus']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['directus']?: ModuleOptions }
 }
 
 declare module 'nuxt/schema' {
-  interface NuxtConfig { ['rolley']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['rolley']?: ModuleOptions }
+  interface NuxtConfig { ['directus']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['directus']?: ModuleOptions }
 }
 
 

package/dist/types.d.ts

@@ -2,13 +2,13 @@
 import { ModuleOptions } from './module'
 
 declare module '@nuxt/schema' {
-  interface NuxtConfig { ['rolley']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['rolley']?: ModuleOptions }
+  interface NuxtConfig { ['directus']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['directus']?: ModuleOptions }
 }
 
 declare module 'nuxt/schema' {
-  interface NuxtConfig { ['rolley']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['rolley']?: ModuleOptions }
+  interface NuxtConfig { ['directus']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['directus']?: ModuleOptions }
 }
 
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-directus-sdk",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "A nuxt module that uses the directus SDK",
   "author": "Matthew Rollinson <matt@rolley.io>",
   "license": "MIT",
@@ -29,17 +29,19 @@
   },
   "dependencies": {
     "@directus/sdk": "^11.0.3",
+    "@directus/shared": "^9.24.0",
     "@nuxt/kit": "^3.7.1",
     "change-case": "^4.1.2",
     "defu": "^6.1.1",
+    "openapi-typescript": "^6.5.5",
     "parse-domain": "^7.0.1",
     "tippy.js": "^6.3.7",
     "ufo": "^1.1.1",
     "vue-toastification": "2.0.0-rc.5"
   },
   "devDependencies": {
+    "@antfu/eslint-config": "^0.41.0",
     "@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",

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

@@ -1,5 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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>;