@decoupla/sdk 0.1.0 → 0.1.2

package/README.md

@@ -1,4 +1,4 @@
-# Decoupla.js
+# @decoupla/sdk
 
 A **type-safe TypeScript client** for the Decoupla headless CMS with integrated CLI tools for schema management and synchronization.
 
@@ -13,47 +13,33 @@ A **type-safe TypeScript client** for the Decoupla headless CMS with integrated
 
 ### 1. Installation
 
-Install via npm (recommended) or Bun. The package name is taken from the npm package metadata.
+Install the package from npm (recommended) or with Bun/Yarn. The package name is
+`@decoupla/sdk` and includes both the TypeScript client and the CLI binary.
 
 ```bash
 # npm
+npm install @decoupla/sdk
 
-const Author = defineContentType({
-  name: 'author',
-  displayName: 'Author',
-  description: 'Blog post authors',
-  fields: {
-    Name: { type: 'string', required: true, isLabel: true },
-    Email: { type: 'string', required: false },
-    Bio: { type: 'text', required: false },
-  },
-});
+# yarn
+yarn add @decoupla/sdk
 
-const BlogPost = defineContentType({
-  name: 'blog_post',
-  displayName: 'Blog Post',
-  description: 'Published blog posts',
-  fields: {
-    Title: { type: 'string', required: true, isLabel: true },
-    Content: { type: 'text', required: true },
-    Author: {
-      type: 'reference',
-      required: false,
-      references: [Author],
-    },
-    IsPublished: { type: 'boolean', required: false },
-    ViewCount: { type: 'int', required: false },
-  },
-});
-
-// Export your configuration
-export default defineConfig({
-  workspace: process.env.DECOUPLA_WORKSPACE!,
-  apiToken: process.env.DECOUPLA_API_TOKEN!,
-  contentTypes: [Author, BlogPost],
-});
+# bun
+bun add @decoupla/sdk
 ```
 
+Notes:
+- The package exports TypeScript types; if you're using TypeScript the types are included.
+- The CLI (`decoupla`) is available via `npx decoupla ...` (npm) or `bunx decoupla ...` (Bun).
+
+After installing, continue to define your content types and configuration (see the
+"Content Type Definition" section below.
+
+### 2. Define Content Types
+
+Define your content types with `defineContentType` (see the "Content Type Definition" section).
+Keep your content type definitions exported from a central module (for example `src/content-types.ts`) so
+both your application code and `decoupla.config.ts` can import the same typed definitions.
+
 ### 3. Sync Your Schema
 
 Run the CLI to sync your local definitions with the backend. You can use `npx` (or `bunx` if you're on Bun) to run the installed binary:
@@ -91,17 +77,30 @@ const posts = await client.getEntries(BlogPost, {
   limit: 10,
 });
 
-// Create an entry
-const newPost = await client.createEntry(BlogPost, {
+// NOTE:
+// The `published` option passed to `createEntry`/`updateEntry` is a server-side
+// command that tells the backend whether the entry should be published immediately.
+// Create an entry as draft (unpublished)
+
+const newPostMeta = await client.createEntry(BlogPost, {
   Title: 'My First Post',
   Content: 'Hello, World!',
-  IsPublished: false,
-});
+}, false);
 
-// Update an entry
-await client.updateEntry(BlogPost, newPost.id, {
-  IsPublished: true,
-});
+// Create an entry and request preloaded relations in the response
+const newPostWithPreload = await client.createEntry(BlogPost, {
+  Title: 'Post with Preload',
+  Content: 'This post requests preload',
+  Author: 'author-id-123',
+}, { published: true, preload: ['Author'] });
+
+// Note: when you pass `preload` the client will return the full normalized entry
+// inside a `{ data: ... }` payload so you can access `newPostWithPreload.data.author` directly.
+
+// Update an entry — provide an options object for publishing and preload behavior
+const updateResult = await client.updateEntry(BlogPost, newPostMeta.id, {
+  Title: 'My First Post (published)'
+}, { published: true, preload: ['Author'] });
 ```
 
 ---
@@ -134,6 +133,43 @@ const MyType = defineContentType({
 Note: `name` is the machine-facing slug used to identify the content type in the API and CLI. It will be normalized to snake_case by the config loader (e.g. "BlogPost" -> "blog_post", "My Type" -> "my_type"). `displayName` is optional and intended as a human-readable label shown in UIs and logs.
 ```
 
+**Important:** We strongly recommend using a `decoupla.config.ts` file to store your `workspace`, `apiToken`, and `contentTypes`.
+The CLI reads this file when you run `decoupla sync`, and keeping a central config ensures the CLI and your application share the same type definitions and settings.
+
+### decoupla.config.ts and contentTypes
+
+Your project should export a configuration file (usually `decoupla.config.ts`) that the CLI reads. The important piece is the `contentTypes` array — this is where you list the content type definitions created with `defineContentType`.
+
+Example `decoupla.config.ts`:
+
+```typescript
+import { defineConfig } from 'decoupla.js';
+import { Author, BlogPost, Category } from './content-types'; // your defineContentType exports
+
+export default defineConfig({
+  workspace: process.env.DECOUPLA_WORKSPACE!,
+  apiToken: process.env.DECOUPLA_API_TOKEN!,
+  contentTypes: [Author, BlogPost, Category],
+});
+```
+
+Notes:
+- The CLI (`decoupla sync`) reads the exported `contentTypes` array and uses it to compare and synchronize your local schema with the remote workspace.
+- Each item in `contentTypes` should be the result of `defineContentType(...)` (the library stores enough metadata to produce API requests and type-safe helpers).
+- Keep the file next to your content-type definitions (for example `src/content-types.ts`) and export each content type so both the CLI and your application code can import the same definitions.
+
+Using content type definitions in your application code:
+
+```typescript
+import { createClient } from '@decoupla/sdk';
+import { BlogPost } from './content-types'; // same defineContentType exported above
+
+const client = createClient({ workspace: '...', apiToken: '...' });
+
+const post = await client.getEntry(BlogPost, 'post-id', { preload: ['Author'] });
+```
+
+
 ### Field Types
 
 Decoupla supports the following field types:
@@ -199,7 +235,6 @@ Decoupla supports the following field types:
   required: true,              // Field must be provided
   isLabel: true,               // Use as display name
   options: ['active', 'inactive'],  // Restrict values (string/string[] only)
-  settings: { /* custom */ },  // Future: localization, validations, etc.
 }
 ```
 
@@ -268,15 +303,17 @@ const client = createClient({
 
 ```typescript
 {
-  getEntry: (contentTypeDef, entryId, options?) => Promise
-  getEntries: (contentTypeDef, options?) => Promise
-  createEntry: (contentTypeDef, fieldValues, published?) => Promise
-  updateEntry: (contentTypeDef, entryId, fieldValues, published?) => Promise
-  upload: (file, filename?) => Promise
-  inspect: () => Promise
-  sync: (contentTypes) => Promise
-  syncWithFields: (contentTypes, options?) => Promise
-  deleteContentType: (contentTypeName) => Promise
+  getEntry: (contentTypeDef, entryId, options?) => Promise<{ data: Entry }>
+  getEntries: (contentTypeDef, options?) => Promise<{ data: Entry[] }>
+  // createEntry/updateEntry accept an options object { published?: boolean; preload?: PreloadSpec }.
+  // When `preload` is provided the client returns the full normalized entry in `{ data: ... }`.
+  createEntry: (contentTypeDef, fieldValues, publishedOrOptions?) => Promise<NormalizedEntryMetadata | { data: Entry }>
+  updateEntry: (contentTypeDef, entryId, fieldValues, publishedOrOptions?) => Promise<NormalizedEntryMetadata | { data: Entry }>
+  upload: (file, filename?) => Promise<UploadResult>
+  inspect: () => Promise<InspectResponse>
+  sync: (contentTypes) => Promise<SyncResult>
+  syncWithFields: (contentTypes, options?) => Promise<SyncResult>
+  deleteContentType: (contentTypeName) => Promise<void>
 }
 ```
 
@@ -304,6 +341,21 @@ console.log(post.data.title); // Type-safe field access
 }
 ```
 
+Note: you can now explicitly select which dataset you want to read using the `contentView` option.
+Acceptable values are `'live'` (published content) and `'preview'` (draft/unpublished data). The default is `'live'`.
+
+The client maps `contentView` to the server `api_type` parameter. Use `contentView: 'preview'` to
+request draft/unpublished data and `contentView: 'live'` for published data.
+
+Example:
+
+```typescript
+const postPreview = await client.getEntry(BlogPost, 'post-id-123', {
+  contentView: 'preview',
+  preload: [['Child', ['Child']]]
+});
+```
+
 Preload supports a nested-array grammar for multi-level reference preloads. Example: to preload a reference field `Child` and then preload its `Child` field, use:
 
 ```typescript
@@ -411,14 +463,24 @@ const results = await client.getEntries(BlogPost, {
 Create a new entry:
 
 ```typescript
-const entry = await client.createEntry(BlogPost, {
+// Boolean `published` positional arg
+const meta = await client.createEntry(BlogPost, {
   Title: 'My First Post',
   Content: 'Hello, World!',
-  IsPublished: false,
-});
+}, false);
+
+// Or use the options object to pass `published` and `preload`.
+// When `preload` is provided the client returns the full normalized entry
+// inside `{ data: ... }` so you can read relations directly.
+const created = await client.createEntry(BlogPost, {
+  Title: 'Post with relations',
+  Content: 'Post body',
+  Author: 'author-id-123',
+}, { published: true, preload: ['Author'] });
 
-console.log(entry.id);        // Entry ID
-console.log(entry.createdAt); // Timestamp
+// Access metadata or full data depending on call:
+console.log(meta.id);               // Entry metadata (no preload)
+console.log(created.data.author);   // Preloaded relation (if requested)
 ```
 
 **Returns:**
@@ -440,10 +502,16 @@ console.log(entry.createdAt); // Timestamp
 Update an existing entry:
 
 ```typescript
+// Backwards-compatible boolean `published` positional arg
+const updatedMeta = await client.updateEntry(BlogPost, 'post-id-123', {
+  ViewCount: 150,
+}, false);
+
+// Or use options object and request preload in the response
 const updated = await client.updateEntry(BlogPost, 'post-id-123', {
   ViewCount: 150,
-  IsPublished: true,
-});
+}, { published: true, preload: ['Author'] });
+// If preload was requested updated will be { data: { ...full entry... } }
 ```
 
 ### `upload(file, filename?)`
@@ -803,15 +871,3 @@ TypeScript enforces correct filter operations per field type:
 { Title: { eq: 'hello' } }
 { ViewCount: { gte: 100 } }
 ```
-
----
-
-## Contributing
-
-Contributions are welcome! Please check the [CONTRIBUTING.md](./CONTRIBUTING.md) file.
-
----
-
-## License
-
-MIT © 2024 Decoupla

package/dist/cli/index.cjs

@@ -8161,6 +8161,10 @@ var preloadType = import_zod.z.lazy(
 var requestSchema = import_zod.z.object({
   type: import_zod.z.string().optional(),
   op_type: import_zod.z.enum(["get_entry", "get_entries", "inspect"]),
+  // Which API surface to target when fetching entries. Defaults to 'live' in the client.
+  api_type: import_zod.z.enum(["live", "preview"]).optional(),
+  // entry_id is required for get_entry operations (top-level param)
+  entry_id: import_zod.z.string().optional(),
   filters: import_zod.z.any().optional(),
   preload: preloadType.optional(),
   sort: import_zod.z.array(import_zod.z.tuple([import_zod.z.string(), import_zod.z.enum(["ASC", "DESC"])])).optional(),
@@ -8295,6 +8299,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
   };
 }
@@ -8312,6 +8318,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) {
@@ -8384,6 +8396,7 @@ var makeRequest = (options) => async (request) => {
   const { apiToken, workspace } = options;
   const {
     op_type,
+    api_type,
     filters,
     type,
     preload,
@@ -8396,15 +8409,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: {
@@ -8441,7 +8459,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;
@@ -8476,34 +8494,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;
@@ -8525,8 +8533,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;
@@ -8651,6 +8661,7 @@ var getEntries = (request) => async (contentTypeDef, options) => {
   const reqBody = {
     type: contentTypeDef.__definition.name,
     op_type: "get_entries",
+    api_type,
     limit,
     offset,
     filters: backendFilters,
@@ -9170,20 +9181,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: {
@@ -9199,15 +9343,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)) {
@@ -9223,8 +9376,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}`, {
@@ -9362,6 +9553,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 }),