nuxt-directus-sdk 5.0.1 → 6.0.0-beta.0

package/README.md

@@ -70,10 +70,16 @@ For cross-domain setups (e.g., `app.example.com` ↔ `api.example.com`), see the
 
 ## Development
 
+> [!IMPORTANT] The playground uses [directus-template-cli](https://github.com/directus-labs/directus-template-cli?tab=readme-ov-file#applying-a-template) `cms` template.
+> Apply the template with `npx directus-template-cli@latest apply` and follow the interactive prompts.
+
 ```bash
 # Install dependencies
 bun install
 
+# Add DIRECTUS_ADMIN_TOKEN to playground .env (don't forget to update your token)
+cp ./playground/.env.example ./playground/.env
+
 # Generate type stubs
 bun run dev:prepare
 

package/dist/cli/index.mjs

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 import { createDirectus, staticToken, rest } from '@directus/sdk';
-import { e as diffRemoteRules, j as formatDiff, d as compareRulesPayloads, g as fetchRemoteRules, b as loadRulesFromPayload, m as pushRules, k as formatPushResult, h as fetchRemoteRulesAsJson } from '../shared/nuxt-directus-sdk.VgzMwq7f.mjs';
+import { d as diffRemoteRules, e as formatDiff, c as compareRulesPayloads, f as fetchRemoteRules, k as loadRulesFromPayload, o as pushRules, g as formatPushResult, b as fetchRemoteRulesAsJson } from '../shared/nuxt-directus-sdk.1qEbZAZ_.mjs';
 
 function loadEnv() {
   const envPath = resolve(process.cwd(), ".env");

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-directus-sdk",
-  "version": "5.0.1",
+  "version": "6.0.0-beta.0",
   "configKey": "directus",
   "compatibility": {
     "nuxt": "^4.0.0"

package/dist/module.mjs

@@ -1,12 +1,12 @@
-import { useLogger, defineNuxtModule, createResolver, addServerHandler, hasNuxtModule, tryResolveModule, addPlugin, addRouteMiddleware, addImportsDir, addComponentsDir, addImportsSources, addTypeTemplate, installModule } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addServerHandler, hasNuxtModule, tryResolveModule, addPlugin, addComponentsDir, addRouteMiddleware, addImportsDir, addImportsSources, addTypeTemplate, installModule } from '@nuxt/kit';
 import { colors } from 'consola/utils';
 import { defu } from 'defu';
 import { joinURL } from 'ufo';
-import { generateTypes } from '../dist/runtime/types/index.js';
+import { generateTypesFromDirectus } from '../dist/runtime/types/index.js';
 import { useUrl } from '../dist/runtime/utils/index.js';
 
 const name = "nuxt-directus-sdk";
-const version = "5.0.1";
+const version = "6.0.0-beta.0";
 
 const configKey = "directus";
 const logger = useLogger("nuxt-directus-sdk");
@@ -59,17 +59,17 @@ const module$1 = defineNuxtModule({
         nuxtApp.options[key] = defu(nuxtApp.options[key], moduleOptions);
       }
     }
+    const loggerMessage = [];
     const devProxyConfig = typeof options.devProxy === "boolean" ? { enabled: options.devProxy } : { ...options.devProxy };
     const directusUrl = serverUrl || clientUrl;
     const devProxyEnabled = devProxyConfig.enabled ?? nuxtApp.options.dev;
     const devProxyPath = devProxyConfig.path ?? "/directus";
     const wsProxyPath = devProxyConfig.wsPath ?? `${devProxyPath}-ws`;
     const wsTarget = joinURL(directusUrl, "websocket");
-    const loggerMessage = [];
     if (devProxyEnabled && nuxtApp.options.dev) {
-      loggerMessage.push(`\u{1F310} Development mode:`);
-      loggerMessage.push(`URL${colors.dim(` ${devProxyPath}`)} proxies ${colors.underline(colors.green(`${directusUrl}`))}`);
-      loggerMessage.push(`WS URL${colors.dim(` ${wsProxyPath}`)} proxies ${colors.underline(colors.green(`${wsTarget}`))}`);
+      loggerMessage.push(`\u{1F310} Development Proxy Mode Enabled:`);
+      loggerMessage.push(`  - URL${colors.dim(` ${devProxyPath}`)} proxies ${colors.underline(colors.green(`${directusUrl}`))}`);
+      loggerMessage.push(`  - WS URL${colors.dim(` ${wsProxyPath}`)} proxies ${colors.underline(colors.green(`${wsTarget}`))}`, "");
       nuxtApp.options.nitro = nuxtApp.options.nitro || {};
       nuxtApp.options.nitro.devProxy = nuxtApp.options.nitro.devProxy || {};
       nuxtApp.options.nitro.devProxy[wsProxyPath] = {
@@ -128,7 +128,7 @@ const module$1 = defineNuxtModule({
         wsPath: wsProxyPath
       };
     } else if (!nuxtApp.options.dev) {
-      loggerMessage.push(`\u{1F310} Production mode:`, ` SDK connects directly to ${colors.dim(`${directusUrl}`)}`);
+      loggerMessage.push(`\u{1F310} Production Mode:`, `  - SDK connects directly to ${colors.dim(`${directusUrl}`)}`, "");
       options.devProxy = false;
     }
     options.directusUrl = clientUrl;
@@ -153,11 +153,22 @@ const module$1 = defineNuxtModule({
           modifiers
         }
       });
+      loggerMessage.push("\u{1F4F7} Nuxt/Image default provider is set to Directus", "");
     }
     addPlugin(resolver.resolve("./runtime/plugin"));
     const hasVisualEditing = options.visualEditor && await tryResolveModule("@directus/visual-editing", new URL(import.meta.url));
     if (hasVisualEditing) {
       addPlugin(resolver.resolve("./runtime/plugins/visual-editor.client"));
+      addComponentsDir({
+        path: resolver.resolve("./runtime/components"),
+        pathPrefix: false,
+        prefix: "",
+        global: true
+      });
+      loggerMessage.push("\u{1F4DD} Visual Editor Components Added", "");
+    }
+    if (options.auth?.enableGlobalAuthMiddleware) {
+      loggerMessage.push("\u{1F512} Auth middleware installed globally.", "");
     }
     addRouteMiddleware({
       name: "auth",
@@ -169,14 +180,6 @@ const module$1 = defineNuxtModule({
       path: resolver.resolve("./runtime/middleware/guest")
     });
     addImportsDir(resolver.resolve("./runtime/composables"));
-    if (hasVisualEditing) {
-      addComponentsDir({
-        path: resolver.resolve("./runtime/components"),
-        pathPrefix: false,
-        prefix: "",
-        global: true
-      });
-    }
     const directusSdkImports = {
       from: "@directus/sdk",
       imports: [
@@ -251,9 +254,8 @@ const module$1 = defineNuxtModule({
         ]
       });
     });
-    loggerMessage.push(``);
     if (options.devtools) {
-      loggerMessage.push(`Directus Admin added to Nuxt DevTools`);
+      loggerMessage.push(`\u{1F4E6} Directus added to Nuxt DevTools`, "");
       nuxtApp.hook("devtools:customTabs", (iframeTabs) => {
         iframeTabs.push({
           name: "directus",
@@ -265,33 +267,29 @@ const module$1 = defineNuxtModule({
           }
         });
       });
-    } else {
-      loggerMessage.push(`${colors.dim(`  Directus Admin was not added to Nuxt DevTools`)}`);
     }
     const typesEnabled = typeof options.types === "boolean" && options.types || options.types && options.types.enabled === true;
     const typesPrefix = typeof options.types === "object" ? options.types.prefix ?? "" : "";
     if (typesEnabled) {
+      loggerMessage.push("\u{1F4CB} Directus Type Generator Enabled");
       if (!options.adminToken) {
-        loggerMessage.push(``, `${colors.bgRedBright(`${colors.red("\u2691 ERROR:")} Unable to generate Types`)}`, `  Fix: Set adminToken in config or DIRECTUS_ADMIN_TOKEN in .env`);
+        loggerMessage.push(`  ${colors.bgRedBright(`${colors.red("\u2691 ERROR:")} Unable to generate Types`)}`, `   Fix: Set adminToken in config or DIRECTUS_ADMIN_TOKEN in .env`);
       } else {
         try {
-          let cachedTypes = null;
+          const { typeString, logs } = await generateTypesFromDirectus(directusUrl, options.adminToken, typesPrefix);
+          loggerMessage.push(...logs);
           addTypeTemplate({
             filename: `types/${configKey}.d.ts`,
-            async getContents() {
-              if (!cachedTypes) {
-                cachedTypes = await generateTypes({
-                  url: directusUrl,
-                  token: options.adminToken,
-                  prefix: typesPrefix
-                });
-              }
-              return cachedTypes;
+            getContents() {
+              return typeString;
             }
           }, { nitro: true, nuxt: true });
-          loggerMessage.push(`${colors.dim(`  Directus Types saved successfully to #build/types/${configKey}.d.ts`)}`);
+          if (logs.some((log) => log.toLowerCase().includes("error"))) {
+            throw new Error(`  ${colors.bgRedBright(`${colors.red("\u2691 ERROR:")} TypeGenerator returned an error`)}`);
+          }
+          loggerMessage.push(`  - Directus Types saved successfully to ${colors.dim(`#build/types/${configKey}.d.ts`)}`);
         } catch (error) {
-          logger.error(error.message);
+          loggerMessage.push(`${error instanceof Error ? error.message : String(error)}`, `  - Fallback DirectusSchema is being used ${colors.dim("(not recommended)")}`);
         }
       }
     }

package/dist/rules/index.mjs

@@ -1,5 +1,5 @@
-import { i as isStandardSchema } from '../shared/nuxt-directus-sdk.VgzMwq7f.mjs';
-export { d as compareRulesPayloads, e as diffRemoteRules, f as diffRules, g as fetchRemoteRules, h as fetchRemoteRulesAsJson, j as formatDiff, k as formatPushResult, q as isValidationStandardSchema, l as loadRulesFromJson, a as loadRulesFromJsonFile, b as loadRulesFromPayload, c as loadRulesFromPayloadFile, n as normalizeRules, p as pullRules, m as pushRules, r as rulesToJson, s as serializeToDirectusApi, o as serializeToJson, t as toDirectusValidation } from '../shared/nuxt-directus-sdk.VgzMwq7f.mjs';
+import { i as isStandardSchema } from '../shared/nuxt-directus-sdk.1qEbZAZ_.mjs';
+export { c as compareRulesPayloads, d as diffRemoteRules, a as diffRules, f as fetchRemoteRules, b as fetchRemoteRulesAsJson, e as formatDiff, g as formatPushResult, h as isValidationStandardSchema, l as loadRulesFromJson, j as loadRulesFromJsonFile, k as loadRulesFromPayload, m as loadRulesFromPayloadFile, n as normalizeRules, p as pullRules, o as pushRules, r as rulesToJson, s as serializeToDirectusApi, q as serializeToJson, t as toDirectusValidation } from '../shared/nuxt-directus-sdk.1qEbZAZ_.mjs';
 import '@directus/sdk';
 
 function isPolicyReference(input) {

package/dist/runtime/components/directus-edit-button.d.vue.ts

@@ -1,10 +1,10 @@
 import type { PrimaryKey } from '@directus/types';
 declare const __VLS_export: <T extends keyof DirectusSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         collection: T;
         item: PrimaryKey;
         mode?: "drawer" | "modal" | "popover";
-    }> & import("vue").PublicProps & (typeof globalThis extends {
+    }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
     expose: (exposed: {}) => void;

package/dist/runtime/components/directus-edit-button.vue.d.ts

@@ -1,10 +1,10 @@
 import type { PrimaryKey } from '@directus/types';
 declare const __VLS_export: <T extends keyof DirectusSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         collection: T;
         item: PrimaryKey;
         mode?: "drawer" | "modal" | "popover";
-    }> & import("vue").PublicProps & (typeof globalThis extends {
+    }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
     expose: (exposed: {}) => void;

package/dist/runtime/components/directus-visual-editor.d.vue.ts

@@ -1,11 +1,11 @@
 import type { PrimaryKey } from '@directus/types';
 declare const __VLS_export: <T extends keyof DirectusSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         collection: T;
         item: PrimaryKey;
         fields?: (string | number | symbol) | (string | number | symbol)[];
         mode?: "drawer" | "modal" | "popover";
-    }> & import("vue").PublicProps & (typeof globalThis extends {
+    }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
     expose: (exposed: {}) => void;

package/dist/runtime/components/directus-visual-editor.vue.d.ts

@@ -1,11 +1,11 @@
 import type { PrimaryKey } from '@directus/types';
 declare const __VLS_export: <T extends keyof DirectusSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         collection: T;
         item: PrimaryKey;
         fields?: (string | number | symbol) | (string | number | symbol)[];
         mode?: "drawer" | "modal" | "popover";
-    }> & import("vue").PublicProps & (typeof globalThis extends {
+    }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
     expose: (exposed: {}) => void;

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

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

package/dist/runtime/middleware/guest.d.ts

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

package/dist/runtime/plugin.d.ts

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

package/dist/runtime/plugins/visual-editor.client.d.ts

@@ -1,8 +1,8 @@
-declare const _default: import("#app").Plugin<{
+declare const _default: import("nuxt/app").Plugin<{
     directusVisualEditing: {
         refresh: () => Promise<void>;
     };
-}> & import("#app").ObjectPlugin<{
+}> & import("nuxt/app").ObjectPlugin<{
     directusVisualEditing: {
         refresh: () => Promise<void>;
     };

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

@@ -0,0 +1,15 @@
+import type { SnapshotField } from '@directus/types';
+export interface TypegenExtension {
+    name: (prefix?: string) => string;
+    isMatch: (field: SnapshotField) => boolean;
+    output: (prefix: string | undefined) => string;
+}
+export declare const typegenExtensions: TypegenExtension[];
+/**
+ * Resolve the first matching extension or false if no extension matches
+ *
+ */
+export declare function resolveTypegenExtension(field: SnapshotField, prefix?: unknown): {
+    name: string;
+    output: string;
+} | false;

package/dist/runtime/types/extensions/index.js

@@ -0,0 +1,15 @@
+import { extension as seoPlugin } from "./seo-plugin.js";
+export const typegenExtensions = [
+  seoPlugin
+];
+export function resolveTypegenExtension(field, prefix) {
+  const safePrefix = typeof prefix === "string" ? prefix : "";
+  const match = typegenExtensions.find((ext) => ext.isMatch(field));
+  if (!match) {
+    return false;
+  }
+  return {
+    name: match.name(safePrefix),
+    output: match.output(safePrefix)
+  };
+}

package/dist/runtime/types/extensions/seo-plugin.d.ts

@@ -0,0 +1,2 @@
+import type { TypegenExtension } from './index.ts.js';
+export declare const extension: TypegenExtension;

package/dist/runtime/types/extensions/seo-plugin.js

@@ -0,0 +1,24 @@
+const interfaceName = "DirectusLabsSeoPlugin";
+export const extension = {
+  name(prefix) {
+    return `${prefix}${interfaceName}`;
+  },
+  isMatch(field) {
+    return field.type === "json" && field.meta?.interface === "seo-interface" && field.meta?.special?.includes("cast-json") === true;
+  },
+  output(prefix) {
+    return `
+interface ${prefix}${interfaceName} {
+    title?: string;
+    meta_description?: string;
+    og_image?: string;
+    additional_fields?: Record<string, unknown>;
+    sitemap?: {
+        change_frequency: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+        priority: string;
+    };
+    no_index?: boolean;
+    no_follow?: boolean;
+}`;
+  }
+};

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

@@ -1,6 +1,34 @@
-import type { GenerateOptions } from './types.js';
+import type { SnapshotCollection, SnapshotField, SnapshotRelation } from '@directus/types';
+import type { TypegenExtension } from './extensions/index.js';
+export declare const FALLBACK_TYPE_STRING = "declare global {\n\ninterface DirectusFile {\n\tid: string;\n}\ninterface DirectusUser {\n\tid: string;\n}\ninterface DirectusSchema { }\n}\n\nexport {};";
 /**
- * Generate TypeScript types from Directus collections using directus-sdk-typegen
- * Wraps the types in a declare global block for Nuxt compatibility
+ * Fetches collections, fields, and relations from a live Directus instance and
+ * generates a TypeScript declaration string.
+ *
+ * @param url - Base URL of the Directus instance.
+ * @param token - Static access token for authentication.
+ * @param prefix - Prefix used when generating interface names.
+ * @returns The generated TypeScript string and an array of log messages.
  */
-export declare function generateTypes(options: GenerateOptions): Promise<string>;
+export declare function generateTypesFromDirectus(url: string, token: string, prefix: string): Promise<{
+    typeString: string;
+    logs: string[];
+}>;
+/**
+ * Transforms Directus collections, fields, and relations into a TypeScript declaration string.
+ *
+ * - Builds a relation map from relations.
+ * - Separates custom and system collections and infers missing system ones.
+ * - Tracks singleton collections.
+ * - Generates collection interfaces and deduplicated extension outputs.
+ * - Generates `DirectusSchema` and `CollectionNames` enum.
+ * - Wraps everything in a `declare global` block.
+ *
+ * @param collections - Collection definitions from the Directus snapshot.
+ * @param fields - Field definitions from the Directus snapshot.
+ * @param relations - Relation definitions from the Directus snapshot.
+ * @param prefix - Prefix used for generating interface names.
+ * @param extensions - Optional type generation extensions.
+ * @returns A TypeScript declaration file as a string.
+ */
+export declare function transformSnapshotToTypeString(collections: SnapshotCollection[], fields: SnapshotField[], relations: SnapshotRelation[], prefix: string, extensions?: TypegenExtension[]): string;

package/dist/runtime/types/generate.js

@@ -1,44 +1,428 @@
-import { useLogger } from "@nuxt/kit";
-import { generateDirectusTypes } from "directus-sdk-typegen";
-import { cleanDoubleSlashes, withoutTrailingSlash } from "ufo";
-const logger = useLogger("nuxt-directus-sdk");
-export async function generateTypes(options) {
-  logger.info(`Generating types from: ${options.url}`);
-  const generatedTypes = await generateDirectusTypes({
-    directusUrl: withoutTrailingSlash(cleanDoubleSlashes(options.url)),
-    directusToken: options.token
+import { createDirectus, isDirectusError, readCollections, readFields, readRelations, rest, staticToken } from "@directus/sdk";
+import { typegenExtensions } from "./extensions/index.js";
+export const FALLBACK_TYPE_STRING = "declare global {\n\ninterface DirectusFile {\n	id: string;\n}\ninterface DirectusUser {\n	id: string;\n}\ninterface DirectusSchema { }\n}\n\nexport {};";
+export async function generateTypesFromDirectus(url, token, prefix) {
+  const logs = [];
+  const client = createDirectus(url).with(rest()).with(staticToken(token));
+  let result = null;
+  try {
+    const [collections, fields, relations] = await Promise.all([
+      client.request(readCollections()),
+      client.request(readFields()),
+      client.request(readRelations())
+    ]);
+    logs.push(`  - Fetched ${collections.length} collections, ${fields.length} fields, ${relations.length} relations`);
+    if (collections.length === 0 || fields.length === 0 || relations.length === 0) {
+      throw new Error(`Empty response from Directus \u2014 collections: ${collections.length}, fields: ${fields.length}, relations: ${relations.length}`);
+    }
+    result = [
+      collections,
+      fields,
+      relations
+    ];
+  } catch (error) {
+    if (isDirectusError(error)) {
+      logs.push(`  - Directus error ${error.errors.map((e) => `[${e.extensions?.code}] ${e.message}`).join(", ")}`);
+    } else {
+      logs.push(`  - Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { typeString: FALLBACK_TYPE_STRING, logs };
+  }
+  const typeString = transformSnapshotToTypeString(...result, prefix);
+  return { typeString, logs };
+}
+export function transformSnapshotToTypeString(collections, fields, relations, prefix, extensions = typegenExtensions) {
+  const relationMap = buildRelationMapFromSnapshot(relations);
+  const collectionsWithDatabaseTables = collections.filter(
+    (c) => c.schema !== null
+  );
+  const customCollections = collectionsWithDatabaseTables.filter(
+    (c) => !collectionIsDirectusSystem(c.collection)
+  );
+  const systemCollectionsFromSnapshot = collectionsWithDatabaseTables.filter(
+    (c) => collectionIsDirectusSystem(c.collection)
+  );
+  const systemCollectionNamesAlreadyPresent = new Set(
+    systemCollectionsFromSnapshot.map((c) => c.collection)
+  );
+  const impliedSystemCollections = [
+    ...new Set(
+      relations.flatMap((r) => [r.collection, r.related_collection ?? ""]).filter(
+        (name) => collectionIsDirectusSystem(name) && !systemCollectionNamesAlreadyPresent.has(name)
+      )
+    )
+  ].map((name) => ({ collection: name, schema: { name }, meta: null }));
+  const allCollectionsForSchema = [
+    ...collectionsWithDatabaseTables,
+    ...impliedSystemCollections
+  ];
+  const singletonCollectionNames = new Set(
+    allCollectionsForSchema.filter((c) => c.meta?.singleton === true).map((c) => c.collection)
+  );
+  const generatedCollections = [
+    ...customCollections,
+    ...systemCollectionsFromSnapshot
+  ].map(
+    (collection) => generateInterfaceForCollection(collection, fields, relationMap, prefix, extensions, singletonCollectionNames)
+  );
+  const seenExtensionOutputs = /* @__PURE__ */ new Set();
+  const uniqueExtensionOutputs = generatedCollections.flatMap((g) => g.extensionOutputs).filter((output) => {
+    if (seenExtensionOutputs.has(output))
+      return false;
+    seenExtensionOutputs.add(output);
+    return true;
+  });
+  const customInterfaceBlocks = generatedCollections.map((g) => g.interfaceBlock);
+  const directusSchemaBlock = generateDirectusSchemaInterface(allCollectionsForSchema, prefix, singletonCollectionNames);
+  const allCollectionNames = allCollectionsForSchema.map((c) => c.collection);
+  const enumBlock = generateCollectionNamesEnum(allCollectionNames, prefix);
+  const bodyParts = [
+    ...uniqueExtensionOutputs,
+    ...customInterfaceBlocks,
+    directusSchemaBlock,
+    enumBlock
+  ];
+  return [
+    "declare global {",
+    "",
+    bodyParts.join("\n\n"),
+    "}",
+    "",
+    "export {};"
+  ].join("\n");
+}
+function collectionIsDirectusSystem(collectionName) {
+  return collectionName.startsWith("directus_");
+}
+function collectionNameToInterfaceName(collectionName, prefix, singletons = /* @__PURE__ */ new Set()) {
+  const isSingleton = singletons.has(collectionName);
+  const transform = (name) => pascalCase(isSingleton ? name : singularize(name));
+  if (collectionIsDirectusSystem(collectionName)) {
+    return transform(collectionName);
+  }
+  return `${prefix}${transform(collectionName)}`;
+}
+function resolveExtensionForField(field, prefix, extensions) {
+  const match = extensions.find((ext) => ext.isMatch(field));
+  if (!match)
+    return null;
+  return {
+    name: match.name(prefix),
+    output: match.output(prefix)
+  };
+}
+function buildRelationMapFromSnapshot(relations) {
+  const relationMap = /* @__PURE__ */ new Map();
+  const getOrCreateCollectionRelations = (collection) => {
+    if (!relationMap.has(collection)) {
+      relationMap.set(collection, { m2o: /* @__PURE__ */ new Map(), o2m: /* @__PURE__ */ new Map(), m2a: /* @__PURE__ */ new Map() });
+    }
+    return relationMap.get(collection);
+  };
+  for (const relation of relations) {
+    const { collection, field, related_collection, meta } = relation;
+    if (!meta)
+      continue;
+    const isM2A = meta.one_allowed_collections && meta.one_allowed_collections.length > 0;
+    if (isM2A) {
+      getOrCreateCollectionRelations(collection).m2a.set(field, meta.one_allowed_collections);
+    } else if (related_collection) {
+      getOrCreateCollectionRelations(collection).m2o.set(field, { relatedCollection: related_collection });
+      if (meta.one_field) {
+        getOrCreateCollectionRelations(related_collection).o2m.set(meta.one_field, { relatedCollection: collection });
+      }
+    }
+  }
+  return relationMap;
+}
+function resolveFieldTypeString(snapshotField, collectionRelations, prefix, extensions, singletons = /* @__PURE__ */ new Set()) {
+  if (collectionRelations?.m2a.has(snapshotField.field)) {
+    const allowedCollections = collectionRelations.m2a.get(snapshotField.field);
+    const unionTypes = allowedCollections.map((c) => collectionNameToInterfaceName(c, prefix, singletons)).join(" | ");
+    return { tsType: `${unionTypes} | string`, extensionOutput: null };
+  }
+  if (collectionRelations?.m2o.has(snapshotField.field)) {
+    const related = collectionRelations.m2o.get(snapshotField.field);
+    return { tsType: `${collectionNameToInterfaceName(related.relatedCollection, prefix, singletons)} | string`, extensionOutput: null };
+  }
+  if (collectionRelations?.o2m.has(snapshotField.field)) {
+    const related = collectionRelations.o2m.get(snapshotField.field);
+    return { tsType: `${collectionNameToInterfaceName(related.relatedCollection, prefix, singletons)}[] | string[]`, extensionOutput: null };
+  }
+  const extensionMatch = resolveExtensionForField(snapshotField, prefix, extensions);
+  if (extensionMatch) {
+    return { tsType: extensionMatch.name, extensionOutput: extensionMatch.output };
+  }
+  return { tsType: determineFieldType(snapshotField), extensionOutput: null };
+}
+const ALIAS_SPECIAL_TYPES = /* @__PURE__ */ new Set(["alias", "no-data", "group"]);
+function fieldIsUiOnlyAlias(field) {
+  const special = field.meta?.special ?? [];
+  return field.type === "alias" && special.some((s) => ALIAS_SPECIAL_TYPES.has(s)) && !special.includes("o2m") && !special.includes("m2o") && !special.includes("m2a") && !special.includes("files") && !special.includes("file");
+}
+function buildInterfaceField(snapshotField, collectionRelations, prefix, extensions, singletons = /* @__PURE__ */ new Set()) {
+  if (fieldIsUiOnlyAlias(snapshotField))
+    return null;
+  const isPrimaryKey = snapshotField.schema?.is_primary_key === true;
+  const isRequired = snapshotField.meta?.required === true;
+  const isNullable = snapshotField.schema?.is_nullable !== false;
+  const { tsType, extensionOutput } = resolveFieldTypeString(snapshotField, collectionRelations, prefix, extensions, singletons);
+  const shouldAppendNull = isNullable && !isRequired && !isPrimaryKey;
+  const finalType = shouldAppendNull ? `${tsType} | null` : tsType;
+  return {
+    interfaceField: {
+      fieldName: snapshotField.field,
+      typeString: finalType,
+      isOptional: !isPrimaryKey && !isRequired,
+      snapshotField,
+      sortOrder: snapshotField.meta?.sort ?? 9999
+    },
+    extensionOutput
+  };
+}
+function generateInterfaceForCollection(collection, allFields, relationMap, prefix, extensions, singletons = /* @__PURE__ */ new Set()) {
+  const collectionName = collection.collection;
+  const interfaceName = collectionNameToInterfaceName(collectionName, prefix, singletons);
+  const collectionRelations = relationMap.get(collectionName);
+  const builtFields = allFields.filter((f) => f.collection === collectionName).map((f) => buildInterfaceField(f, collectionRelations, prefix, extensions, singletons)).filter((f) => f !== null).sort((a, b) => a.interfaceField.sortOrder - b.interfaceField.sortOrder);
+  const extensionOutputs = builtFields.map((f) => f.extensionOutput).filter((o) => o !== null);
+  const fieldLines = builtFields.map(({ interfaceField }) => {
+    const jsDoc = generateJSDocComment(interfaceField.snapshotField);
+    const optionalMarker = interfaceField.isOptional ? "?" : "";
+    const declaration = `	${interfaceField.fieldName}${optionalMarker}: ${interfaceField.typeString};`;
+    return jsDoc ? `${jsDoc}	${interfaceField.fieldName}${optionalMarker}: ${interfaceField.typeString};` : declaration;
+  });
+  return {
+    interfaceBlock: `interface ${interfaceName} {
+${fieldLines.join("\n")}
+}`,
+    extensionOutputs
+  };
+}
+function generateDirectusSchemaInterface(allCollections, prefix, singletons = /* @__PURE__ */ new Set()) {
+  const entries = allCollections.map((collection) => {
+    const isSingleton = collection.meta?.singleton === true;
+    const interfaceName = collectionNameToInterfaceName(collection.collection, prefix, singletons);
+    const valueType = isSingleton ? interfaceName : `${interfaceName}[]`;
+    return `	${collection.collection}: ${valueType};`;
   });
-  let processedTypes = generatedTypes;
-  if (options.prefix) {
-    processedTypes = processedTypes.replace(
-      /^export interface ((?!Schema\b)(?!Directus)\w+)/gm,
-      (match, interfaceName) => {
-        if (interfaceName.startsWith("Directus")) {
-          return match;
+  return `interface DirectusSchema {
+${entries.join("\n")}
+}`;
+}
+function generateCollectionNamesEnum(collectionNames, prefix) {
+  const entries = collectionNames.map((name) => `	${name} = '${name}'`);
+  return `export enum ${prefix}CollectionNames {
+${entries.join(",\n")}
+}`;
+}
+function determineFieldType(field) {
+  if (field.meta?.special?.includes("translations")) {
+    const translationsCollection = field.relation?.collection;
+    if (translationsCollection) {
+      const translationType = pascalCase(singularize(translationsCollection));
+      return `${translationType}[] | null`;
+    }
+  }
+  if (field.relation?.collection) {
+    const relatedTypeName = pascalCase(singularize(field.relation.collection));
+    switch (field.relation.type) {
+      case "many":
+        return `${relatedTypeName}[] | string[]`;
+      case "m2a": {
+        const allowedCollections = field.relation.allowedCollections;
+        if (Array.isArray(allowedCollections) && allowedCollections.length > 0) {
+          const unionTypes = allowedCollections.map((collection) => pascalCase(singularize(collection))).join(" | ");
+          return `${unionTypes} | string`;
         }
-        return `export interface ${options.prefix}${interfaceName}`;
+        console.warn(
+          "[determineFieldType] m2a relation missing allowedCollections. Falling back to string."
+        );
+        return "string";
       }
+      default:
+        return `${relatedTypeName} | string`;
+    }
+  }
+  const choices = field.meta?.options?.choices;
+  if (Array.isArray(choices) && choices.length > 0) {
+    const choiceValues = choices.map(
+      (choice) => choice.value === null ? "null" : escapeStringLiteral(choice.value)
     );
-    processedTypes = processedTypes.split("\n").map((line) => {
-      if (line.match(/^export interface /)) {
-        return line;
+    const unionOfChoices = [...new Set(choiceValues)].join(" | ");
+    const interfacesWithMultiSelect = ["select-multiple", "select-multiple-dropdown", "select-multiple-checkbox"];
+    if (interfacesWithMultiSelect.includes(field.meta.interface)) {
+      return `Array<${unionOfChoices}>`;
+    }
+    return unionOfChoices;
+  }
+  switch (field.type) {
+    case "boolean":
+      return "boolean";
+    case "json": {
+      const nestedFields = field.meta?.options?.fields;
+      if (Array.isArray(nestedFields) && nestedFields.length > 0) {
+        const nestedTypes = nestedFields.map((nestedField) => {
+          const propertyName = nestedField.field ?? nestedField.name;
+          const fieldType = determineFieldType(nestedField);
+          return `${propertyName}: ${fieldType}`;
+        });
+        return `Array<{ ${nestedTypes.join("; ")} }>`;
       }
-      return line.replace(
-        /\b(?!Directus)([A-Z]\w+)(\[\])?/g,
-        (match, typeName, array) => {
-          if (typeName.startsWith("Directus") || ["String", "Number", "Boolean", "Date", "Array", "Record", "Promise", "Partial", "Required", "Readonly", "Pick", "Omit", "Exclude", "Extract"].includes(typeName) || ["string", "number", "boolean", "any", "unknown", "void", "never", "null", "undefined"].includes(typeName.toLowerCase())) {
-            return match;
-          }
-          return `${options.prefix}${typeName}${array || ""}`;
-        }
-      );
-    }).join("\n");
+      if (field.meta?.interface === "input-code") {
+        return "Record<string, unknown>";
+      }
+      if (field.meta?.interface === "tags") {
+        return "string[]";
+      }
+      return "'json'";
+    }
+    case "csv":
+      return "'csv'";
+    case "dateTime":
+    case "timestamp":
+      return "'datetime'";
+    case "date":
+      return "'date'";
+    case "time":
+      return "'time'";
+    case "integer":
+    case "bigInteger":
+    case "float":
+    case "decimal":
+      return "number";
+    default:
+      return "string";
   }
-  const typesWithoutExport = processedTypes.replace(/export interface Schema/g, "interface DirectusSchema").replace(/^export interface /gm, "interface ");
-  return `declare global {
-${typesWithoutExport}
 }
-
-export {};
-`;
+function escapeStringLiteral(value) {
+  switch (typeof value) {
+    case "string": {
+      const backslashEscaped = value.replace(/\\/g, "\\\\");
+      if (/^\w+$/.test(backslashEscaped)) {
+        const singleQuoteEscaped = backslashEscaped.replace(/'/g, "\\'");
+        return `'${singleQuoteEscaped}'`;
+      }
+      const templateLiteralEscaped = backslashEscaped.replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+      return `\`${templateLiteralEscaped}\``;
+    }
+    case "boolean":
+    case "number":
+      return String(value);
+    case "undefined":
+      return "null";
+    default:
+      if (value === void 0 || value === null) {
+        return "null";
+      }
+      return JSON.stringify(value);
+  }
+}
+function generateJSDocComment(field) {
+  const comments = [];
+  if (field.meta?.note && !field.meta.note.startsWith("$t")) {
+    comments.push(`@description ${field.meta.note}`);
+  }
+  if (field.schema?.is_primary_key) {
+    comments.push("@primaryKey");
+  }
+  if (field.meta?.required) {
+    comments.push("@required");
+  }
+  return comments.length > 0 ? `	/** ${comments.join(" ")} */
+` : "";
+}
+function pascalCase(value) {
+  return value.split(/[\s_-]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+const singularizeExceptions = /* @__PURE__ */ new Map([
+  // invariant (same singular/plural)
+  ["sheep", "sheep"],
+  ["fish", "fish"],
+  ["series", "series"],
+  ["species", "species"],
+  ["deer", "deer"],
+  ["aircraft", "aircraft"],
+  ["news", "news"],
+  // irregular
+  ["children", "child"],
+  ["men", "man"],
+  ["women", "woman"],
+  ["teeth", "tooth"],
+  ["feet", "foot"],
+  ["mice", "mouse"],
+  ["geese", "goose"],
+  ["oxen", "ox"],
+  // -ves special cases (fe endings)
+  ["knives", "knife"],
+  ["wives", "wife"],
+  ["lives", "life"],
+  ["leaves", "leaf"],
+  ["loaves", "loaf"],
+  ["wolves", "wolf"],
+  ["calves", "calf"],
+  ["halves", "half"],
+  ["selves", "self"],
+  ["elves", "elf"],
+  // Latin / Greek
+  ["analyses", "analysis"],
+  ["diagnoses", "diagnosis"],
+  ["theses", "thesis"],
+  ["crises", "crisis"],
+  ["phenomena", "phenomenon"],
+  ["criteria", "criterion"],
+  // -us -> -i
+  ["cacti", "cactus"],
+  ["fungi", "fungus"],
+  ["nuclei", "nucleus"],
+  ["syllabi", "syllabus"],
+  // -a -> -um
+  ["bacteria", "bacterium"],
+  ["curricula", "curriculum"],
+  // exceptions to oes -> o
+  ["toes", "toe"]
+]);
+const singularizeRules = [
+  // ies -> y
+  (word) => {
+    if (word.endsWith("ies") && word.length > 3) {
+      return `${word.slice(0, -3)}y`;
+    }
+    return null;
+  },
+  // oes -> o
+  (word) => {
+    if (word.endsWith("oes")) {
+      return word.slice(0, -2);
+    }
+    return null;
+  },
+  // es -> remove (ch, sh, s, x, z)
+  (word) => {
+    if (/(?:ch|sh|[sxz])es$/.test(word)) {
+      return word.slice(0, -2);
+    }
+    return null;
+  },
+  // fallback: trailing s (guarded)
+  (word) => {
+    if (word.endsWith("s") && !word.endsWith("ss") && word.length > 3 && !word.endsWith("us") && !word.endsWith("is")) {
+      return word.slice(0, -1);
+    }
+    return null;
+  }
+];
+function singularize(word) {
+  if (!word || typeof word !== "string")
+    return "";
+  const lower = word.toLowerCase();
+  const exception = singularizeExceptions.get(lower);
+  if (exception)
+    return exception;
+  for (const rule of singularizeRules) {
+    const result = rule(lower);
+    if (result)
+      return result;
+  }
+  return word;
 }

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

@@ -1 +1 @@
-export { generateTypes } from './generate.js';
+export { FALLBACK_TYPE_STRING, generateTypesFromDirectus } from './generate.js';

package/dist/runtime/types/index.js

@@ -1 +1 @@
-export { generateTypes } from "./generate.js";
+export { FALLBACK_TYPE_STRING, generateTypesFromDirectus } from "./generate.js";

package/dist/shared/{nuxt-directus-sdk.VgzMwq7f.mjs → nuxt-directus-sdk.1qEbZAZ_.mjs}

@@ -1413,4 +1413,4 @@ function formatPushResult(result) {
   return lines.join("\n");
 }
 
-export { loadRulesFromJsonFile as a, loadRulesFromPayload as b, loadRulesFromPayloadFile as c, compareRulesPayloads as d, diffRemoteRules as e, diffRules as f, fetchRemoteRules as g, fetchRemoteRulesAsJson as h, isStandardSchema as i, formatDiff as j, formatPushResult as k, loadRulesFromJson as l, pushRules as m, normalizeRules as n, serializeToJson as o, pullRules as p, isValidationStandardSchema as q, rulesToJson as r, serializeToDirectusApi as s, toDirectusValidation as t };
+export { diffRules as a, fetchRemoteRulesAsJson as b, compareRulesPayloads as c, diffRemoteRules as d, formatDiff as e, fetchRemoteRules as f, formatPushResult as g, isValidationStandardSchema as h, isStandardSchema as i, loadRulesFromJsonFile as j, loadRulesFromPayload as k, loadRulesFromJson as l, loadRulesFromPayloadFile as m, normalizeRules as n, pushRules as o, pullRules as p, serializeToJson as q, rulesToJson as r, serializeToDirectusApi as s, toDirectusValidation as t };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "nuxt-directus-sdk",
   "type": "module",
-  "version": "5.0.1",
+  "version": "6.0.0-beta.0",
+  "packageManager": "pnpm@10.32.1",
   "description": "A Directus nuxt module that uses the Directus SDK",
   "author": "Matthew Rollinson <matt@rolley.io>",
   "license": "MIT",
@@ -30,22 +31,23 @@
   ],
   "scripts": {
     "prepack": "nuxt-module-build 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 && npm publish && git push --follow-tags",
-    "release:next": "npm run lint && npm run prepack && npm publish --tag next && git push --follow-tags",
-    "lint": "eslint . --fix",
+    "dev": "pnpm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt prepare playground",
+    "release": "pnpm run lint && pnpm run test && pnpm run prepack && changelogen --release --push --no-github",
+    "release:next": "pnpm run lint && pnpm run test && pnpm run prepack && changelogen --release --prerelease beta --push --no-github",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "test": "vitest run",
     "test:watch": "vitest watch",
-    "docs:dev": "bun run dev:prepare && vitepress dev docs",
-    "docs:build": "bun run dev:prepare && vitepress build docs",
+    "docs:dev": "pnpm run dev:prepare && vitepress dev docs",
+    "docs:build": "pnpm run dev:prepare && vitepress build docs",
     "docs:preview": "vitepress preview docs"
   },
   "peerDependencies": {
-    "@directus/sdk": ">=20.0.0",
-    "@directus/types": ">=13.0.0",
-    "@directus/visual-editing": ">=1.1.0",
+    "@directus/sdk": ">=21.0.0",
+    "@directus/types": ">=15.0.0",
+    "@directus/visual-editing": ">=2.0.0",
     "@nuxt/image": ">=2.0.0"
   },
   "peerDependenciesMeta": {
@@ -60,29 +62,28 @@
     }
   },
   "dependencies": {
-    "@nuxt/kit": "^4.0.0",
-    "change-case": "^4.1.2",
-    "defu": "^6.1.1",
-    "directus-sdk-typegen": "^0.2.1",
+    "@nuxt/kit": "^4.4.2",
+    "defu": "^6.1.7",
     "http-proxy": "^1.18.1",
-    "ufo": "^1.6.1"
+    "ufo": "^1.6.3"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^4.10.0",
-    "@directus/sdk": "^20.0.0",
-    "@directus/types": "^13.0.0",
-    "@directus/visual-editing": "^1.1.0",
-    "@nuxt/devtools": "latest",
+    "@directus/sdk": "^21.2.2",
+    "@directus/types": "^15.0.2",
+    "@directus/visual-editing": "^2.0.0",
+    "@nuxt/devtools": "^3.2.4",
     "@nuxt/image": "^2.0.0",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/schema": "^4.1.2",
-    "@nuxt/test-utils": "^3.19.2",
+    "@nuxt/schema": "^4.4.2",
+    "@nuxt/test-utils": "^4.0.2",
     "@types/http-proxy": "^1.17.17",
     "changelogen": "^0.6.1",
     "eslint": "^9.22.0",
-    "nuxt": "^4.1.2",
-    "vitepress": "^1.6.3",
-    "vitest": "^3.0.8",
+    "nuxt": "^4.4.2",
+    "typescript": "^6.0.3",
+    "vitepress": "^1.6.4",
+    "vitest": "^4.1.4",
     "vue-tsc": "^3.0.8"
   },
   "unbuild": {