@decoupla/sdk 0.1.0 → 0.1.2

package/dist/cli/index.js

@@ -8142,6 +8142,10 @@ var preloadType = z.lazy(
 var requestSchema = z.object({
   type: z.string().optional(),
   op_type: z.enum(["get_entry", "get_entries", "inspect"]),
+  // Which API surface to target when fetching entries. Defaults to 'live' in the client.
+  api_type: z.enum(["live", "preview"]).optional(),
+  // entry_id is required for get_entry operations (top-level param)
+  entry_id: z.string().optional(),
   filters: z.any().optional(),
   preload: preloadType.optional(),
   sort: z.array(z.tuple([z.string(), z.enum(["ASC", "DESC"])])).optional(),
@@ -8276,6 +8280,8 @@ function buildCreateFieldRequest(modelId, fieldName, fieldDef) {
     control,
     required: fieldDef.required ?? false,
     description: (_b = fieldDef.settings) == null ? void 0 : _b.description,
+    is_label: fieldDef.isLabel ?? false,
+    options: fieldDef.options,
     meta: Object.keys(meta).length > 0 ? meta : void 0
   };
 }
@@ -8293,6 +8299,12 @@ function buildUpdateFieldRequest(fieldId, changes) {
   if (changes.description !== void 0) {
     request.description = changes.description;
   }
+  if (changes.isLabel !== void 0) {
+    request.is_label = !!changes.isLabel;
+  }
+  if (changes.options !== void 0) {
+    request.options = changes.options;
+  }
   if (changes.references !== void 0) {
     request.meta = { ...changes.meta || {}, reference_types: changes.references };
   } else if (changes.meta !== void 0) {
@@ -8365,6 +8377,7 @@ var makeRequest = (options) => async (request) => {
   const { apiToken, workspace } = options;
   const {
     op_type,
+    api_type,
     filters,
     type,
     preload,
@@ -8377,15 +8390,20 @@ var makeRequest = (options) => async (request) => {
     acc.push({ field, direction });
     return acc;
   }, void 0);
+  const outgoingApiType = op_type === "inspect" ? void 0 : api_type ?? "live";
   const requestBody = {
     op_type,
     type,
+    // pass through entry_id when present (used by get_entry)
+    entry_id: request.entry_id,
     filters,
     preload,
     sort: sendSort,
     limit,
     offset
   };
+  if (outgoingApiType)
+    requestBody.api_type = outgoingApiType;
   const req = await fetch(`${DECOUPLA_API_URL_BASE}${workspace}`, {
     method: "POST",
     headers: {
@@ -8422,7 +8440,7 @@ ${errorDetails}`);
   return respData;
 };
 var getEntry = (request) => async (contentTypeDef, entryId, options) => {
-  var _a;
+  var _a, _b;
   const normalizePreload = (p) => {
     if (!Array.isArray(p))
       return p;
@@ -8457,34 +8475,24 @@ var getEntry = (request) => async (contentTypeDef, entryId, options) => {
     }
     return out;
   };
+  const chosenApiType = (options == null ? void 0 : options.contentView) ?? "live";
   const reqBody = {
     op_type: "get_entry",
     type: contentTypeDef.__definition.name,
     entry_id: entryId,
-    preload: normalizePreload((options == null ? void 0 : options.preload) || [])
+    preload: normalizePreload((options == null ? void 0 : options.preload) || []),
+    api_type: chosenApiType
   };
   try {
     debug("[getEntry] request body:", JSON.stringify(reqBody));
   } catch (e) {
   }
-  const resp = await fetch(`${DECOUPLA_API_URL_BASE}${process.env.DECOUPLA_WORKSPACE}`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${process.env.DECOUPLA_API_TOKEN}`
-    },
-    body: JSON.stringify(reqBody)
-  });
-  const respData = await resp.json();
+  const resp = await request(reqBody);
   try {
-    debug("[getEntry] raw response:", JSON.stringify(respData, null, 2));
+    debug("[getEntry] raw response:", JSON.stringify(resp, null, 2));
   } catch (e) {
   }
-  if (respData.errors) {
-    console.error("Get Entry Error:", respData);
-    throw new Error(`API Error: ${respData.errors.map((e) => e.message).join(", ")}`);
-  }
-  const entry = (_a = respData.data) == null ? void 0 : _a.entry;
+  const entry = ((_a = resp == null ? void 0 : resp.data) == null ? void 0 : _a.entry) || ((_b = resp == null ? void 0 : resp.data) == null ? void 0 : _b.node);
   const normalizedEntry = {};
   for (const [key, value] of Object.entries(entry || {})) {
     normalizedEntry[snakeToCamel(key)] = value;
@@ -8506,8 +8514,10 @@ var getEntries = (request) => async (contentTypeDef, options) => {
     limit,
     offset,
     preload = [],
-    sort = []
+    sort = [],
+    contentView: optContentView
   } = options;
+  const api_type = optContentView ?? "live";
   const normalizePreload = (p) => {
     if (!Array.isArray(p))
       return p;
@@ -8632,6 +8642,7 @@ var getEntries = (request) => async (contentTypeDef, options) => {
   const reqBody = {
     type: contentTypeDef.__definition.name,
     op_type: "get_entries",
+    api_type,
     limit,
     offset,
     filters: backendFilters,
@@ -9151,20 +9162,153 @@ var normalizeEntryMetadata = (entry) => ({
   createdAt: entry.created_at,
   updatedAt: entry.updated_at
 });
-var createEntry = (options) => async (contentTypeDef, fieldValues, published = true) => {
-  var _a;
+var createEntry = (options) => async (contentTypeDef, fieldValues, optionsParam) => {
+  var _a, _b, _c;
   const { apiToken, workspace } = options;
+  const opts = typeof optionsParam === "boolean" ? { published: optionsParam } : optionsParam || {};
+  const published = opts.published ?? true;
   const validation = validateFieldValues(fieldValues);
   if (!validation.valid) {
     throw new Error(validation.error || "Invalid field values");
   }
   const normalizedFieldValues = normalizeFieldValues(fieldValues);
+  try {
+    const fieldDefs = ((_a = contentTypeDef.__definition) == null ? void 0 : _a.fields) || {};
+    const keyMap = /* @__PURE__ */ new Map();
+    for (const defKey of Object.keys(fieldDefs)) {
+      keyMap.set(defKey, defKey);
+      try {
+        keyMap.set(camelToSnake(defKey), defKey);
+      } catch (e) {
+      }
+      try {
+        keyMap.set(snakeToCamel(camelToSnake(defKey)), defKey);
+      } catch (e) {
+      }
+    }
+    for (const [k, v] of Object.entries(normalizedFieldValues)) {
+      const defKey = keyMap.get(k) || void 0;
+      if (!defKey)
+        continue;
+      const fdef = fieldDefs[defKey];
+      if (!fdef)
+        continue;
+      if (fdef.type === "date") {
+        const toDateOnly = (val) => {
+          if (val instanceof Date) {
+            const y = val.getFullYear();
+            const m = String(val.getMonth() + 1).padStart(2, "0");
+            const d = String(val.getDate()).padStart(2, "0");
+            return `${y}-${m}-${d}`;
+          }
+          if (typeof val === "string") {
+            if (/^\d{4}-\d{2}-\d{2}$/.test(val))
+              return val;
+            const parsed = new Date(val);
+            if (!isNaN(parsed.getTime())) {
+              const y = parsed.getFullYear();
+              const m = String(parsed.getMonth() + 1).padStart(2, "0");
+              const d = String(parsed.getDate()).padStart(2, "0");
+              return `${y}-${m}-${d}`;
+            }
+          }
+          return val;
+        };
+        normalizedFieldValues[k] = toDateOnly(v);
+      }
+    }
+  } catch (e) {
+  }
+  try {
+    const fieldDefs = ((_b = contentTypeDef.__definition) == null ? void 0 : _b.fields) || {};
+    const keyMap = /* @__PURE__ */ new Map();
+    for (const defKey of Object.keys(fieldDefs)) {
+      keyMap.set(defKey, defKey);
+      try {
+        keyMap.set(camelToSnake(defKey), defKey);
+      } catch (e) {
+      }
+      try {
+        keyMap.set(snakeToCamel(camelToSnake(defKey)), defKey);
+      } catch (e) {
+      }
+    }
+    for (const [k, v] of Object.entries(normalizedFieldValues)) {
+      const defKey = keyMap.get(k) || keyMap.get(k) || void 0;
+      if (!defKey)
+        continue;
+      const fdef = fieldDefs[defKey];
+      if (!fdef)
+        continue;
+      if (fdef.type === "date") {
+        const toDateOnly = (val) => {
+          if (val instanceof Date) {
+            const y = val.getFullYear();
+            const m = String(val.getMonth() + 1).padStart(2, "0");
+            const d = String(val.getDate()).padStart(2, "0");
+            return `${y}-${m}-${d}`;
+          }
+          if (typeof val === "string") {
+            if (/^\d{4}-\d{2}-\d{2}$/.test(val))
+              return val;
+            const parsed = new Date(val);
+            if (!isNaN(parsed.getTime())) {
+              const y = parsed.getFullYear();
+              const m = String(parsed.getMonth() + 1).padStart(2, "0");
+              const d = String(parsed.getDate()).padStart(2, "0");
+              return `${y}-${m}-${d}`;
+            }
+          }
+          return val;
+        };
+        normalizedFieldValues[k] = toDateOnly(v);
+      }
+    }
+  } catch (e) {
+  }
+  const normalizePreload = (p) => {
+    if (!Array.isArray(p))
+      return p;
+    const out = [];
+    for (const item of p) {
+      if (typeof item === "string") {
+        out.push(camelToSnake(item));
+        continue;
+      }
+      if (!Array.isArray(item)) {
+        out.push(item);
+        continue;
+      }
+      const [key, inner] = item;
+      if (inner == null) {
+        out.push(camelToSnake(key));
+        continue;
+      }
+      let innerArr;
+      if (typeof inner === "string") {
+        innerArr = [inner];
+      } else if (Array.isArray(inner)) {
+        if (inner.length === 2 && typeof inner[0] === "string" && (Array.isArray(inner[1]) || inner[1] == null)) {
+          innerArr = [inner];
+        } else {
+          innerArr = inner;
+        }
+      } else {
+        innerArr = [inner];
+      }
+      out.push([camelToSnake(key), normalizePreload(innerArr)]);
+    }
+    return out;
+  };
   const requestBody = {
     op_type: "create_entry",
     type: contentTypeDef.__definition.name,
     field_values: normalizedFieldValues,
     published
   };
+  if (opts.preload) {
+    requestBody.preload = normalizePreload(opts.preload);
+  }
   const response = await fetch(`${DECOUPLA_API_URL_BASE}${workspace}`, {
     method: "POST",
     headers: {
@@ -9180,15 +9324,24 @@ var createEntry = (options) => async (contentTypeDef, fieldValues, published = t
     throw new Error(`Failed to create entry: ${errorMessages}`);
   }
   const createResponse = respData;
-  const entry = (_a = createResponse.data) == null ? void 0 : _a.entry;
+  const entry = (_c = createResponse.data) == null ? void 0 : _c.entry;
   if (!entry) {
     throw new Error(
       `Failed to create entry: Content type "${contentTypeDef.__definition.name}" returned null. This typically means the content type has no fields defined. Please add at least one field to the content type before creating entries.`
     );
   }
+  if (opts.preload) {
+    const normalized = { id: entry.id };
+    for (const [key, value] of Object.entries(entry)) {
+      if (key !== "id") {
+        normalized[snakeToCamel(key)] = value;
+      }
+    }
+    return { data: normalized };
+  }
   return normalizeEntryMetadata(entry);
 };
-var updateEntry = (options) => async (contentTypeDef, entryId, fieldValues, published) => {
+var updateEntry = (options) => async (contentTypeDef, entryId, fieldValues, optionsParam) => {
   var _a;
   const { apiToken, workspace } = options;
   if (!isValidUUID(entryId)) {
@@ -9204,8 +9357,46 @@ var updateEntry = (options) => async (contentTypeDef, entryId, fieldValues, publ
     entry_id: entryId,
     field_values: normalizedFieldValues
   };
-  if (published !== void 0) {
-    requestBody.published = published;
+  const opts = typeof optionsParam === "boolean" ? { published: optionsParam } : optionsParam || {};
+  if (opts.published !== void 0) {
+    requestBody.published = opts.published;
+  }
+  const normalizePreload = (p) => {
+    if (!Array.isArray(p))
+      return p;
+    const out = [];
+    for (const item of p) {
+      if (typeof item === "string") {
+        out.push(camelToSnake(item));
+        continue;
+      }
+      if (!Array.isArray(item)) {
+        out.push(item);
+        continue;
+      }
+      const [key, inner] = item;
+      if (inner == null) {
+        out.push(camelToSnake(key));
+        continue;
+      }
+      let innerArr;
+      if (typeof inner === "string") {
+        innerArr = [inner];
+      } else if (Array.isArray(inner)) {
+        if (inner.length === 2 && typeof inner[0] === "string" && (Array.isArray(inner[1]) || inner[1] == null)) {
+          innerArr = [inner];
+        } else {
+          innerArr = inner;
+        }
+      } else {
+        innerArr = [inner];
+      }
+      out.push([camelToSnake(key), normalizePreload(innerArr)]);
+    }
+    return out;
+  };
+  if (opts.preload) {
+    requestBody.preload = normalizePreload(opts.preload);
   }
   debug(`[DEBUG] Update Entry Request:`, JSON.stringify(requestBody, null, 2));
   const response = await fetch(`${DECOUPLA_API_URL_BASE}${workspace}`, {
@@ -9343,6 +9534,37 @@ var createClient = (config) => {
     getEntries: getEntries(request),
     // Note: inline preload literal inference is supported by getEntries overloads.
     inspect: inspect(request),
+    /**
+     * Validate whether the current token can read the requested content view.
+     * Returns true when the view is accessible, false when an authorization error is returned.
+     * This helper inspects the remote for a content type and issues a harmless get_entries
+     * against that content type using the requested view; it treats a structured
+     * `{ errors: [{ field: 'authorization', ... }] }` as a permission failure.
+     */
+    validateContentView: async (view) => {
+      var _a, _b;
+      try {
+        const inspectResp = await inspect(request)();
+        const firstCT = inspectResp.data.content_types && inspectResp.data.content_types[0];
+        if (!firstCT)
+          return true;
+        const typeName = firstCT.slug || firstCT.id;
+        const resp = await request({ op_type: "get_entries", type: typeName, limit: 1, api_type: view }).catch((err) => ({ __err: err }));
+        if (resp == null ? void 0 : resp.__err) {
+          throw resp.__err;
+        }
+        if (resp.errors || ((_a = resp.data) == null ? void 0 : _a.errors)) {
+          const errors = resp.errors || ((_b = resp.data) == null ? void 0 : _b.errors) || [];
+          return !errors.some((e) => e.field === "authorization");
+        }
+        return true;
+      } catch (e) {
+        if (e && typeof e === "object" && e.errors) {
+          return !e.errors.some((er) => er.field === "authorization");
+        }
+        throw e;
+      }
+    },
     sync: sync(request),
     syncWithFields: syncWithFieldsBound,
     upload: upload({ apiToken, workspace }),