@meeovi/directus-client 1.0.3 → 1.0.5

package/dist/generators/form-engine.d.ts

@@ -1,4 +1,9 @@
 import type { DirectusField } from '../schema/types';
+export interface FormEngineOptions {
+    clearOnSuccess?: boolean;
+    onSuccess?: () => void;
+    onError?: (msg: string) => void;
+}
 export interface GeneratedFormField {
     key: string;
     widget: string;
@@ -9,5 +14,23 @@ export interface GeneratedFormField {
     isFile?: boolean;
     isRelational?: boolean;
 }
+/**
+ * Convert a Directus field into a UI-ready form field schema.
+ */
 export declare function generateFormField(field: DirectusField): GeneratedFormField;
+/**
+ * Convert an entire collection's fields into a form schema.
+ */
 export declare function generateFormSchema(fields: DirectusField[]): GeneratedFormField[];
+/**
+ * Framework-agnostic form engine for submitting Directus items.
+ */
+export declare function createFormEngine(collectionName: string, fields: DirectusField[], directusClient: any, opts?: FormEngineOptions): {
+    form: Record<string, any>;
+    submit: () => Promise<{
+        error: string | null;
+        success: string | null;
+    }>;
+    readonly error: string | null;
+    readonly success: string | null;
+};

package/dist/generators/form-engine.js

@@ -1,4 +1,7 @@
 import { widgetRegistry } from './widget-registry';
+/**
+ * Convert a Directus field into a UI-ready form field schema.
+ */
 export function generateFormField(field) {
     const widget = widgetRegistry[field.interface || 'input'];
     const base = {
@@ -10,13 +13,100 @@ export function generateFormField(field) {
         isFile: widget.isFile,
         isRelational: widget.isRelational
     };
-    if ((field.interface === 'repeater' || field.interface === 'group') && field.options?.fields) {
+    // Repeater or group fields contain nested fields
+    if ((field.interface === 'repeater' || field.interface === 'group') &&
+        Array.isArray(field.options?.fields)) {
         base.fields = field.options.fields.map((sub) => generateFormField(sub));
     }
     return base;
 }
+/**
+ * Convert an entire collection's fields into a form schema.
+ */
 export function generateFormSchema(fields) {
     return fields
         .filter(f => f.interface !== 'presentation' && f.interface !== 'divider')
         .map(generateFormField);
 }
+/**
+ * Framework-agnostic form engine for submitting Directus items.
+ */
+export function createFormEngine(collectionName, fields, directusClient, opts) {
+    const form = {};
+    let error = null;
+    let success = null;
+    /**
+     * Validate a single field using Directus validation metadata.
+     */
+    const validateField = (field) => {
+        if (!field.validation)
+            return null;
+        try {
+            const validation = field.validation;
+            if (validation._and) {
+                for (const rule of validation._and) {
+                    const fieldName = Object.keys(rule)[0];
+                    if (!fieldName)
+                        continue;
+                    const ruleDef = rule[fieldName];
+                    if (ruleDef?._regex) {
+                        const regex = new RegExp(ruleDef._regex);
+                        const value = String(form[field.field] ?? '');
+                        if (!regex.test(value)) {
+                            return field.validation_message || `${field.field} failed validation`;
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            return `Validation error for ${field.field}`;
+        }
+        return null;
+    };
+    /**
+     * Validate all fields before submission.
+     */
+    const validate = () => {
+        error = null;
+        for (const field of fields) {
+            const result = validateField(field);
+            if (result) {
+                error = result;
+                opts?.onError?.(result);
+                return false;
+            }
+        }
+        return true;
+    };
+    /**
+     * Submit the form to Directus.
+     */
+    const submit = async () => {
+        if (!validate())
+            return { error, success };
+        const result = await directusClient.request(directusClient.createItem(collectionName, form));
+        if (result?.error) {
+            error = result.error.message;
+            opts?.onError?.(error);
+            return { error, success };
+        }
+        success = `${collectionName} created successfully`;
+        if (opts?.clearOnSuccess) {
+            for (const key of Object.keys(form))
+                delete form[key];
+        }
+        opts?.onSuccess?.();
+        return { error, success };
+    };
+    return {
+        form,
+        submit,
+        get error() {
+            return error;
+        },
+        get success() {
+            return success;
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meeovi/directus-client",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Directus Client Library with auto generating forms and tables, Directus SDK and Types, and vue/react components for Directus Visual Editing.",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/src/client/createClient.ts

@@ -9,13 +9,13 @@ import {
   deleteItem,
   uploadFiles,
   readSingleton,
-  readFieldsByCollection,
-  type DirectusClient
+  readFieldsByCollection
 } from '@directus/sdk';
+import type { RestClient } from '@directus/sdk';
 
 export interface MeeoviDirectusClient<Schema> {
-  client: DirectusClient<Schema>;
-  request: any;
+  client: RestClient<Schema>;
+  request: RestClient<Schema>['request'];
   readItem: typeof readItem;
   readItems: typeof readItems;
   createItem: typeof createItem;
@@ -43,4 +43,4 @@ export function createMeeoviDirectusClient<Schema>(url: string): MeeoviDirectusC
     readSingleton,
     readFieldsByCollection
   };
-}
+}

package/src/generators/table-engine.ts

@@ -1,11 +1,45 @@
 import type { DirectusField } from '../schema/types';
 
-export function generateTableSchema(fields: DirectusField[]) {
+export interface TableColumn {
+  key: string;
+  label: string;
+  type: string;
+  sortable?: boolean;
+  hidden?: boolean;
+}
+
+/**
+ * Convert Directus fields into a table schema.
+ */
+export function generateTableSchema(fields: DirectusField[]): TableColumn[] {
   return fields
-    .filter(f => !f.hidden)
-    .map(f => ({
+    .filter((f) => !f.hidden)
+    .map((f) => ({
       key: f.field,
-      label: f.field.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
-      type: f.type
+      label: prettifyLabel(f.field),
+      type: f.type,
+      sortable: true,
+      hidden: false
     }));
 }
+
+/**
+ * Convert "product_name" → "Product Name"
+ */
+function prettifyLabel(str: string): string {
+  return str
+    .replace(/_/g, ' ')
+    .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+/**
+ * Fetch table rows from Directus.
+ */
+export async function fetchTableRows(
+  directus: any,
+  collection: string
+): Promise<any[]> {
+  return await directus.request(
+    directus.readItems(collection)
+  );
+}