@nestledjs/data-browser 0.1.7 → 0.1.8

package/lib/types/index.js

@@ -1,16 +1,16 @@
-const e = {
+const initialState = {
   search: "",
   debouncedSearch: "",
   skip: 0,
   pageSize: 20,
   sort: { orderBy: "id", orderDirection: "desc" },
   visibleColumns: [],
-  showColumnSelector: !1,
+  showColumnSelector: false,
   searchFields: [],
-  showSearchFieldSelector: !1,
+  showSearchFieldSelector: false,
   filters: {},
-  showFilters: !1
+  showFilters: false
 };
 export {
-  e as initialState
+  initialState
 };

package/lib/utils/graphql-utils.js

@@ -1,193 +1,269 @@
-import { FormFieldClass as u } from "@nestledjs/forms";
-import { getPluralName as j } from "@nestledjs/helpers";
-function S(t, a) {
+import { FormFieldClass } from "@nestledjs/forms";
+import { getPluralName } from "@nestledjs/helpers";
+function getEnumValues(sdk, enumType) {
   try {
-    const n = t[a];
-    if (!n || typeof n != "object")
+    const enumObject = sdk[enumType];
+    if (!enumObject || typeof enumObject !== "object") {
       return null;
-    const r = Object.values(n).filter((l) => typeof l == "string");
-    if (r.length === 0) {
-      const l = Object.keys(n).filter((b) => isNaN(Number(b)));
-      return l.length > 0 ? l : null;
     }
-    return r;
-  } catch (n) {
-    return console.warn(`Failed to get enum values for type ${a}:`, n), null;
+    const values = Object.values(enumObject).filter((value) => typeof value === "string");
+    if (values.length === 0) {
+      const keys = Object.keys(enumObject).filter((key) => isNaN(Number(key)));
+      return keys.length > 0 ? keys : null;
+    }
+    return values;
+  } catch (error) {
+    console.warn(`Failed to get enum values for type ${enumType}:`, error);
+    return null;
   }
 }
-function O(t) {
-  return t === t.toUpperCase() && t.length > 1 ? t.charAt(0).toUpperCase() + t.slice(1).toLowerCase() : t;
+function normalizeModelNameForDocument(modelName) {
+  if (modelName === modelName.toUpperCase() && modelName.length > 1) {
+    return modelName.charAt(0).toUpperCase() + modelName.slice(1).toLowerCase();
+  }
+  return modelName;
 }
-function G(t, a) {
-  if (!a || !a.name)
+function getAdminDocuments(sdk, model) {
+  if (!model || !model.name) {
     throw new Error("Invalid model provided to getAdminDocuments");
-  const n = O(a.name), r = O(j(a.name)), l = `__Admin${n}Document`, b = `__Admin${r}Document`, g = `__AdminUpdate${n}Document`, i = `__AdminDelete${n}Document`, m = `__AdminCreate${n}Document`, c = {
-    query: t[l],
+  }
+  const normalizedModelName = normalizeModelNameForDocument(model.name);
+  const normalizedPluralName = normalizeModelNameForDocument(getPluralName(model.name));
+  const singleQueryDocumentName = `__Admin${normalizedModelName}Document`;
+  const listQueryDocumentName = `__Admin${normalizedPluralName}Document`;
+  const updateDocumentName = `__AdminUpdate${normalizedModelName}Document`;
+  const deleteDocumentName = `__AdminDelete${normalizedModelName}Document`;
+  const createDocumentName = `__AdminCreate${normalizedModelName}Document`;
+  const documents = {
+    query: sdk[singleQueryDocumentName],
     // For single item
-    listQuery: t[b],
+    listQuery: sdk[listQueryDocumentName],
     // For lists
-    update: t[g],
-    delete: t[i],
-    create: t[m]
-  }, e = [];
-  if (c.query || e.push(l), c.listQuery || e.push(b), c.create || e.push(m), c.update || e.push(g), c.delete || e.push(i), e.length > 0)
-    throw console.error(`[GraphQL Documents] Missing documents for model "${a.name}":`, {
-      model: a.name,
-      normalizedModelName: n,
-      normalizedPluralName: r,
-      missingDocuments: e,
-      availableDocuments: Object.keys(t).filter(
-        (h) => h.includes("Admin") && h.includes("Document")
+    update: sdk[updateDocumentName],
+    delete: sdk[deleteDocumentName],
+    create: sdk[createDocumentName]
+  };
+  const missingDocuments = [];
+  if (!documents.query) missingDocuments.push(singleQueryDocumentName);
+  if (!documents.listQuery) missingDocuments.push(listQueryDocumentName);
+  if (!documents.create) missingDocuments.push(createDocumentName);
+  if (!documents.update) missingDocuments.push(updateDocumentName);
+  if (!documents.delete) missingDocuments.push(deleteDocumentName);
+  if (missingDocuments.length > 0) {
+    console.error(`[GraphQL Documents] Missing documents for model "${model.name}":`, {
+      model: model.name,
+      normalizedModelName,
+      normalizedPluralName,
+      missingDocuments,
+      availableDocuments: Object.keys(sdk).filter(
+        (key) => key.includes("Admin") && key.includes("Document")
       )
-    }), new Error(
-      `Missing GraphQL documents for model "${a.name}": ${e.join(", ")}. Please ensure the API server is running and the GraphQL schema is up to date.`
+    });
+    throw new Error(
+      `Missing GraphQL documents for model "${model.name}": ${missingDocuments.join(", ")}. Please ensure the API server is running and the GraphQL schema is up to date.`
     );
-  return c;
+  }
+  return documents;
 }
-function z(t, a) {
-  const n = t.name.charAt(0).toLowerCase() + t.name.slice(1);
-  switch (a) {
+function getMutationName(model, operation) {
+  const modelName = model.name.charAt(0).toLowerCase() + model.name.slice(1);
+  switch (operation) {
     case "create":
-      return `create${t.name}`;
+      return `create${model.name}`;
     case "update":
-      return `update${t.name}`;
+      return `update${model.name}`;
     case "delete":
-      return `delete${t.name}`;
+      return `delete${model.name}`;
     default:
-      return n;
+      return modelName;
   }
 }
-function I(t, a, n, r, l) {
-  const g = a.fields.filter((e) => !(n === "create" && e.isId || e.isReadOnly || e.isGenerated || e.isUpdatedAt || e.name === "createdAt" || e.relationName && e.isList)).map((e) => {
-    var $;
-    const h = e.name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (d) => d.toUpperCase());
-    let o = r && n === "update" ? r[e.name] : void 0;
-    if ((e.type.toLowerCase() === "datetime" || e.type.toLowerCase() === "date") && (o instanceof Date || o && typeof o == "string"))
-      try {
-        const d = o instanceof Date ? o : new Date(o);
-        e.type.toLowerCase() === "date" ? o = d.toISOString().split("T")[0] : o = d.toISOString().substring(0, 16);
-      } catch (d) {
-        console.warn(`Failed to convert date value for field ${e.name}:`, d), o = "";
+function buildFormFields(sdk, model, operation, currentItem, isSubmitting) {
+  const editableFields = model.fields.filter((field) => {
+    if (operation === "create" && field.isId) return false;
+    if (field.isReadOnly || field.isGenerated) return false;
+    if (field.isUpdatedAt || field.name === "createdAt") return false;
+    if (field.relationName && field.isList) return false;
+    return true;
+  });
+  const formFields = editableFields.map((field) => {
+    var _a;
+    const label = field.name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (str) => str.toUpperCase());
+    let initialValue = currentItem && operation === "update" ? currentItem[field.name] : void 0;
+    if (field.type.toLowerCase() === "datetime" || field.type.toLowerCase() === "date") {
+      if (initialValue instanceof Date || initialValue && typeof initialValue === "string") {
+        try {
+          const dateValue = initialValue instanceof Date ? initialValue : new Date(initialValue);
+          if (field.type.toLowerCase() === "date") {
+            initialValue = dateValue.toISOString().split("T")[0];
+          } else {
+            const isoString = dateValue.toISOString();
+            initialValue = isoString.substring(0, 16);
+          }
+        } catch (e) {
+          console.warn(`Failed to convert date value for field ${field.name}:`, e);
+          initialValue = "";
+        }
       }
-    if (o && typeof o == "object" && !Array.isArray(o) && e.relationName) {
-      const d = o;
-      d.id && typeof d.id == "string" ? o = d.id : o = "";
     }
-    o === null && e.type.toLowerCase() !== "boolean" && (o = "");
-    const _ = !!e.isList ? !1 : !e.isOptional, p = {
-      label: h,
-      required: _,
-      ...o !== void 0 && { value: o }
+    if (initialValue && typeof initialValue === "object" && !Array.isArray(initialValue) && field.relationName) {
+      const relationObj = initialValue;
+      if (relationObj.id && typeof relationObj.id === "string") {
+        initialValue = relationObj.id;
+      } else {
+        initialValue = "";
+      }
+    }
+    if (initialValue === null && field.type.toLowerCase() !== "boolean") {
+      initialValue = "";
+    }
+    const isArrayField = Boolean(field.isList);
+    const isRequired = isArrayField ? false : !field.isOptional;
+    const options = {
+      label,
+      required: isRequired,
+      ...initialValue !== void 0 && { value: initialValue }
     };
-    switch (e.type.toLowerCase()) {
+    switch (field.type.toLowerCase()) {
       case "string":
-        return e.name.toLowerCase().includes("email") ? u.email(e.name, p) : e.name.toLowerCase().includes("description") || e.name.toLowerCase().includes("content") || e.name.toLowerCase().includes("notes") ? u.textArea(e.name, p) : u.text(e.name, p);
+        if (field.name.toLowerCase().includes("email")) {
+          return FormFieldClass.email(field.name, options);
+        }
+        if (field.name.toLowerCase().includes("description") || field.name.toLowerCase().includes("content") || field.name.toLowerCase().includes("notes")) {
+          return FormFieldClass.textArea(field.name, options);
+        }
+        return FormFieldClass.text(field.name, options);
       case "int":
       case "bigint":
-        return u.text(e.name, p);
+        return FormFieldClass.text(field.name, options);
       case "float":
       case "decimal":
-        return u.text(e.name, p);
+        return FormFieldClass.text(field.name, options);
       case "boolean": {
-        const f = r && n === "update" ? !!r[e.name] : !1;
-        return u.checkbox(e.name, {
-          ...p,
-          required: !1,
-          ...n === "update" && { value: f }
+        const booleanValue = currentItem && operation === "update" ? Boolean(currentItem[field.name]) : false;
+        return FormFieldClass.checkbox(field.name, {
+          ...options,
+          required: false,
+          ...operation === "update" && { value: booleanValue }
         });
       }
       case "datetime":
-        return u.dateTimePicker(e.name, p);
+        return FormFieldClass.dateTimePicker(field.name, options);
       case "date":
-        return u.datePicker(e.name, p);
+        return FormFieldClass.datePicker(field.name, options);
       default:
-        const d = S(t, e.type);
-        if (d) {
-          const f = d.map((s) => ({
-            value: s,
-            label: s.replace(/_/g, " ").toLowerCase().replace(/^./, (C) => C.toUpperCase())
+        const enumValues = getEnumValues(sdk, field.type);
+        if (enumValues) {
+          const selectOptions = enumValues.map((value) => ({
+            value,
+            label: value.replace(/_/g, " ").toLowerCase().replace(/^./, (str) => str.toUpperCase())
           }));
-          return u.select(e.name, {
-            ...p,
-            options: f
+          return FormFieldClass.select(field.name, {
+            ...options,
+            options: selectOptions
           });
         }
-        if (e.relationName && !e.isList) {
-          const f = (($ = e.relationFromFields) == null ? void 0 : $[0]) || e.name;
-          let s = r && n === "update" ? r[f] : void 0;
-          s && typeof s == "object" && s.id && (s = s.id), s === null && (s = "");
-          const C = `__Admin${e.type}sDocument`, F = `${e.type}sDocument`, N = t[C] || t[F];
-          if (N) {
-            let w = "id";
-            e.type === "Course" ? w = "title" : e.type === "User" || e.type === "Program" ? w = "name" : w = "title";
-            let A = [];
-            if (r && n === "update") {
-              const y = r[e.name];
-              if (y && typeof y == "object" && y.id) {
-                const L = y[w] || y.title || y.name || y.id;
-                A = [
+        if (field.relationName && !field.isList) {
+          const relationFieldName = ((_a = field.relationFromFields) == null ? void 0 : _a[0]) || field.name;
+          let relationValue = currentItem && operation === "update" ? currentItem[relationFieldName] : void 0;
+          if (relationValue && typeof relationValue === "object" && relationValue.id) {
+            relationValue = relationValue.id;
+          }
+          if (relationValue === null) {
+            relationValue = "";
+          }
+          const adminDocumentName = `__Admin${field.type}sDocument`;
+          const regularDocumentName = `${field.type}sDocument`;
+          const relationDocument = sdk[adminDocumentName] || sdk[regularDocumentName];
+          if (relationDocument) {
+            let searchField = "id";
+            if (field.type === "Course") {
+              searchField = "title";
+            } else if (field.type === "User") {
+              searchField = "name";
+            } else if (field.type === "Program") {
+              searchField = "name";
+            } else {
+              searchField = "title";
+            }
+            let initialOptions = [];
+            if (currentItem && operation === "update") {
+              const currentRelationData = currentItem[field.name];
+              if (currentRelationData && typeof currentRelationData === "object" && currentRelationData.id) {
+                const displayLabel = currentRelationData[searchField] || currentRelationData.title || currentRelationData.name || currentRelationData.id;
+                initialOptions = [
                   {
-                    value: y.id,
-                    label: L
+                    value: currentRelationData.id,
+                    label: displayLabel
                   }
                 ];
               }
             }
-            return u.searchSelectApollo(f, {
-              label: h,
+            return FormFieldClass.searchSelectApollo(relationFieldName, {
+              label,
               // Remove "ID" suffix - just use the field name
-              required: p.required,
-              dataType: e.type.toLowerCase() + "s",
+              required: options.required,
+              dataType: field.type.toLowerCase() + "s",
               // e.g., Course → courses
-              document: N,
-              searchFields: [w],
+              document: relationDocument,
+              searchFields: [searchField],
               // For searching
-              selectOptionsFunction: (y) => {
-                const L = y.map((D) => ({
-                  value: D.id,
-                  label: D[w] || D.title || D.name || D.id
-                })), v = [...A];
-                return L.forEach((D) => {
-                  v.find((x) => x.value === D.value) || v.push(D);
-                }), v;
+              selectOptionsFunction: (items) => {
+                const queryOptions = items.map((item) => ({
+                  value: item.id,
+                  label: item[searchField] || item.title || item.name || item.id
+                }));
+                const allOptions = [...initialOptions];
+                queryOptions.forEach((option) => {
+                  if (!allOptions.find((existing) => existing.value === option.value)) {
+                    allOptions.push(option);
+                  }
+                });
+                return allOptions;
               },
-              ...A.length > 0 && { initialOptions: A },
+              ...initialOptions.length > 0 && { initialOptions },
               // Provide initial options if available
-              ...s !== void 0 && { value: s }
+              ...relationValue !== void 0 && { value: relationValue }
             });
-          } else
-            return console.warn(
-              `GraphQL document ${C} or ${F} not found for relation ${e.type}. Using text input instead.`
-            ), u.text(f, {
-              label: `${h} ID`,
-              required: p.required,
+          } else {
+            console.warn(
+              `GraphQL document ${adminDocumentName} or ${regularDocumentName} not found for relation ${field.type}. Using text input instead.`
+            );
+            return FormFieldClass.text(relationFieldName, {
+              label: `${label} ID`,
+              required: options.required,
               helpText: "Enter the ID of the related record",
-              ...s !== void 0 && { value: s }
+              ...relationValue !== void 0 && { value: relationValue }
             });
+          }
         }
-        if (e.kind === "enum" && e.enumValues) {
-          const f = e.enumValues.map((s) => ({
-            value: s,
-            label: s.replace(/_/g, " ").toLowerCase().replace(/^./, (C) => C.toUpperCase())
+        if (field.kind === "enum" && field.enumValues) {
+          const selectOptions = field.enumValues.map((value) => ({
+            value,
+            label: value.replace(/_/g, " ").toLowerCase().replace(/^./, (str) => str.toUpperCase())
           }));
-          return u.select(e.name, {
-            ...p,
-            options: f
+          return FormFieldClass.select(field.name, {
+            ...options,
+            options: selectOptions
           });
         }
-        return u.text(e.name, p);
+        return FormFieldClass.text(field.name, options);
     }
-  }), c = l ? n === "create" ? "Creating..." : "Updating..." : n === "create" ? "Create" : "Update";
-  return g.push(
-    u.button("submit", {
-      text: c,
+  });
+  const loadingText = operation === "create" ? "Creating..." : "Updating...";
+  const defaultText = operation === "create" ? "Create" : "Update";
+  const buttonText = isSubmitting ? loadingText : defaultText;
+  formFields.push(
+    FormFieldClass.button("submit", {
+      text: buttonText,
       type: "submit",
       variant: "primary",
-      disabled: l
+      disabled: isSubmitting
     })
-  ), g;
+  );
+  return formFields;
 }
-const V = /* @__PURE__ */ new Set([
+const SYSTEM_FIELDS = /* @__PURE__ */ new Set([
   "__typename",
   // Apollo type annotation
   "id",
@@ -201,65 +277,78 @@ const V = /* @__PURE__ */ new Set([
   "_meta"
   // Prisma metadata
 ]);
-function U(t, a) {
-  return V.has(t) || a === void 0;
+function shouldSkipValue(key, value) {
+  return SYSTEM_FIELDS.has(key) || value === void 0;
 }
-function q(t, a) {
-  if (t === "")
+function convertStringValue(value, field) {
+  if (value === "") {
     return null;
-  if ((a == null ? void 0 : a.type.toLowerCase()) === "datetime" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(t))
+  }
+  if ((field == null ? void 0 : field.type.toLowerCase()) === "datetime" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(value)) {
     try {
-      return new Date(t).toISOString();
-    } catch {
-      return console.warn(`Failed to convert datetime-local value: ${t}`), t;
+      const date = new Date(value);
+      return date.toISOString();
+    } catch (e) {
+      console.warn(`Failed to convert datetime-local value: ${value}`);
+      return value;
+    }
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  const numericPattern = /^\d+(\.\d+)?$/;
+  if (numericPattern.test(value)) {
+    const numericValue = Number(value);
+    if (!isNaN(numericValue)) {
+      return numericValue;
     }
-  if (t === "true") return !0;
-  if (t === "false") return !1;
-  if (/^\d+(\.\d+)?$/.test(t)) {
-    const r = Number(t);
-    if (!isNaN(r))
-      return r;
   }
-  return t;
+  return value;
 }
-function T(t, a) {
-  const n = P(t, a);
-  return Object.keys(n).length > 0 ? n : null;
+function processNestedObject(value, model) {
+  const cleanedNested = cleanFormInput(value, model);
+  return Object.keys(cleanedNested).length > 0 ? cleanedNested : null;
 }
-function P(t, a) {
-  var l, b, g;
-  const n = {}, r = new Set(
-    ((b = (l = a == null ? void 0 : a.fields) == null ? void 0 : l.filter((i) => i.type.toLowerCase() === "boolean")) == null ? void 0 : b.map((i) => i.name)) || []
+function cleanFormInput(input, model) {
+  var _a, _b, _c;
+  const cleaned = {};
+  const booleanFields = new Set(
+    ((_b = (_a = model == null ? void 0 : model.fields) == null ? void 0 : _a.filter((field) => field.type.toLowerCase() === "boolean")) == null ? void 0 : _b.map((field) => field.name)) || []
   );
-  for (const [i, m] of Object.entries(t)) {
-    if (r.has(i) && m === void 0) {
-      n[i] = !1;
+  for (const [key, value] of Object.entries(input)) {
+    if (booleanFields.has(key) && value === void 0) {
+      cleaned[key] = false;
       continue;
     }
-    if (!U(i, m)) {
-      if (typeof m == "string") {
-        const c = (g = a == null ? void 0 : a.fields) == null ? void 0 : g.find((h) => h.name === i), e = q(m, c);
-        e !== null && (n[i] = e);
-        continue;
+    if (shouldSkipValue(key, value)) {
+      continue;
+    }
+    if (typeof value === "string") {
+      const field = (_c = model == null ? void 0 : model.fields) == null ? void 0 : _c.find((f) => f.name === key);
+      const convertedValue = convertStringValue(value, field);
+      if (convertedValue !== null) {
+        cleaned[key] = convertedValue;
       }
-      if (typeof m == "object" && m !== null && !Array.isArray(m)) {
-        const c = m;
-        if (c.value !== void 0 && c.label !== void 0 && typeof c.value == "string") {
-          n[i] = c.value;
-          continue;
-        }
-        const e = T(c, a);
-        e !== null && (n[i] = e);
+      continue;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const obj = value;
+      if (obj.value !== void 0 && obj.label !== void 0 && typeof obj.value === "string") {
+        cleaned[key] = obj.value;
         continue;
       }
-      n[i] = m;
+      const processedNested = processNestedObject(obj, model);
+      if (processedNested !== null) {
+        cleaned[key] = processedNested;
+      }
+      continue;
     }
+    cleaned[key] = value;
   }
-  return n;
+  return cleaned;
 }
 export {
-  I as buildFormFields,
-  P as cleanFormInput,
-  G as getAdminDocuments,
-  z as getMutationName
+  buildFormFields,
+  cleanFormInput,
+  getAdminDocuments,
+  getMutationName
 };