@datocms/cma-client 5.1.11 → 5.1.12

package/src/generated/resources/Upload.ts

@@ -1,11 +1,6 @@
 import * as Utils from '@datocms/rest-client-utils';
 import BaseResource from '../../BaseResource';
-import type {
-  ItemTypeDefinition,
-  ToItemDefinition,
-  ToItemDefinitionAsRequest,
-  ToItemDefinitionWithNestedBlocks,
-} from '../../utilities/itemDefinition';
+import type { ItemTypeDefinition } from '../../utilities/itemDefinition';
 import type * as ApiTypes from '../ApiTypes';
 import type * as RawApiTypes from '../RawApiTypes';
 
@@ -267,19 +262,13 @@ export default class Upload extends BaseResource {
   references<D extends ItemTypeDefinition = ItemTypeDefinition>(
     uploadId: string | ApiTypes.UploadData,
     queryParams: ApiTypes.UploadReferencesHrefSchema & { nested: true },
-  ): Promise<
-    ApiTypes.UploadReferencesTargetSchema<
-      ToItemDefinitionWithNestedBlocks<NoInfer<D>>
-    >
-  >;
+  ): Promise<ApiTypes.UploadReferencesTargetSchema<NoInfer<D>, true>>;
   references<D extends ItemTypeDefinition = ItemTypeDefinition>(
     uploadId: string | ApiTypes.UploadData,
     queryParams?: ApiTypes.UploadReferencesHrefSchema & {
       nested?: false | undefined;
     },
-  ): Promise<
-    ApiTypes.UploadReferencesTargetSchema<ToItemDefinition<NoInfer<D>>>
-  >;
+  ): Promise<ApiTypes.UploadReferencesTargetSchema<NoInfer<D>, false>>;
   /**
    * Referenced records
    *
@@ -308,27 +297,17 @@ export default class Upload extends BaseResource {
   rawReferences<D extends ItemTypeDefinition = ItemTypeDefinition>(
     uploadId: string,
     queryParams: RawApiTypes.UploadReferencesHrefSchema & { nested: true },
-  ): Promise<
-    RawApiTypes.UploadReferencesTargetSchema<
-      ToItemDefinitionWithNestedBlocks<NoInfer<D>>
-    >
-  >;
+  ): Promise<RawApiTypes.UploadReferencesTargetSchema<NoInfer<D>, true>>;
   rawReferences<D extends ItemTypeDefinition = ItemTypeDefinition>(
     uploadId: string,
     queryParams?: RawApiTypes.UploadReferencesHrefSchema & {
       nested?: false | undefined;
     },
-  ): Promise<
-    RawApiTypes.UploadReferencesTargetSchema<ToItemDefinition<NoInfer<D>>>
-  >;
+  ): Promise<RawApiTypes.UploadReferencesTargetSchema<NoInfer<D>, false>>;
   rawReferences<D extends ItemTypeDefinition = ItemTypeDefinition>(
     uploadId: string,
     queryParams?: RawApiTypes.UploadReferencesHrefSchema,
-  ): Promise<
-    RawApiTypes.UploadReferencesTargetSchema<
-      ToItemDefinitionWithNestedBlocks<NoInfer<D>>
-    >
-  >;
+  ): Promise<RawApiTypes.UploadReferencesTargetSchema<NoInfer<D>, true>>;
   /**
    * Referenced records
    *
@@ -347,11 +326,9 @@ export default class Upload extends BaseResource {
         url: `/uploads/${uploadId}/references`,
         queryParams,
       })
-      .then<
-        RawApiTypes.UploadReferencesTargetSchema<
-          ToItemDefinitionWithNestedBlocks<NoInfer<D>>
-        >
-      >(Utils.deserializeRawResponseBodyWithItems);
+      .then<RawApiTypes.UploadReferencesTargetSchema<NoInfer<D>, true>>(
+        Utils.deserializeRawResponseBodyWithItems,
+      );
   }
 
   /**

package/src/index.ts

@@ -5,6 +5,7 @@ export { Client } from './generated/Client';
 export type { ClientConfigOptions } from './generated/Client';
 export * as Resources from './generated/resources';
 export * from './utilities/buildBlockRecord';
+export * from './utilities/duplicateBlockRecord';
 export * from './utilities/fieldsContainingReferences';
 export * from './utilities/id';
 export * from './utilities/inspectItem';

package/src/utilities/buildBlockRecord.ts

@@ -1,75 +1,19 @@
 import * as Utils from '@datocms/rest-client-utils';
-import type {
-  ItemWithOptionalIdAndMeta,
-  NewBlockInARequest,
-} from '../fieldTypes';
+import type { NewBlockInRequest } from '../fieldTypes';
 import type * as ApiTypes from '../generated/ApiTypes';
 import { Item } from '../generated/resources';
-import type {
-  ItemTypeDefinition,
-  ToItemDefinitionAsRequest,
-  ToItemDefinitionWithNestedBlocks,
-} from './itemDefinition';
-import { mapBlocksInNonLocalizedFieldValue } from './recursiveBlocks';
-import type { SchemaRepository } from './schemaRepository';
+import type { ItemTypeDefinition } from './itemDefinition';
 
 type NoInfer<T> = [T][T extends any ? 0 : never];
 
 export function buildBlockRecord<
   D extends ItemTypeDefinition = ItemTypeDefinition,
->(
-  body: ApiTypes.ItemUpdateSchema<ToItemDefinitionAsRequest<NoInfer<D>>>,
-): NewBlockInARequest<ToItemDefinitionAsRequest<NoInfer<D>>> {
+>(body: ApiTypes.ItemUpdateSchema<NoInfer<D>>): NewBlockInRequest<NoInfer<D>> {
   return Utils.serializeRequestBody<{
-    data: NewBlockInARequest<ToItemDefinitionAsRequest<NoInfer<D>>>;
+    data: NewBlockInRequest<NoInfer<D>>;
   }>(body, {
     type: Item.TYPE,
     attributes: '*',
     relationships: ['item_type'],
   }).data;
 }
-
-export async function duplicateBlockRecord<
-  D extends ItemTypeDefinition = ItemTypeDefinition,
->(
-  existingBlock: ItemWithOptionalIdAndMeta<
-    ToItemDefinitionWithNestedBlocks<NoInfer<D>>
-  >,
-  schemaRepository: SchemaRepository,
-): Promise<NewBlockInARequest<ToItemDefinitionAsRequest<NoInfer<D>>>> {
-  const { type, attributes, relationships } = existingBlock;
-
-  const itemType = await schemaRepository.getRawItemTypeById(
-    existingBlock.relationships.item_type.data.id,
-  );
-
-  const newBlock = {
-    type,
-    relationships,
-    attributes,
-  } as NewBlockInARequest;
-
-  const fields = await schemaRepository.getRawItemTypeFields(itemType);
-
-  for (const field of fields) {
-    newBlock.attributes[field.attributes.api_key] =
-      mapBlocksInNonLocalizedFieldValue(
-        schemaRepository,
-        field.attributes.field_type,
-        newBlock.attributes[field.attributes.api_key],
-        (block, path) => {
-          if (typeof block === 'string') {
-            throw new Error(
-              `Block cannot be duplicated as it contains nested block at ${path.join('.')} that is expressed as ID (${block}) instead of full object!`,
-            );
-          }
-
-          const { id, meta, ...blockWithoutIdAndMeta } = block;
-
-          return blockWithoutIdAndMeta;
-        },
-      );
-  }
-
-  return newBlock as NewBlockInARequest<ToItemDefinitionAsRequest<NoInfer<D>>>;
-}

package/src/utilities/duplicateBlockRecord.ts

@@ -0,0 +1,52 @@
+import type {
+  ItemWithOptionalIdAndMeta,
+  NewBlockInRequest,
+} from '../fieldTypes';
+import type { ItemTypeDefinition } from './itemDefinition';
+import { mapBlocksInNonLocalizedFieldValue } from './recursiveBlocks';
+import type { SchemaRepository } from './schemaRepository';
+
+type NoInfer<T> = [T][T extends any ? 0 : never];
+
+export async function duplicateBlockRecord<
+  D extends ItemTypeDefinition = ItemTypeDefinition,
+>(
+  existingBlock: ItemWithOptionalIdAndMeta<NoInfer<D>>,
+  schemaRepository: SchemaRepository,
+): Promise<NewBlockInRequest<NoInfer<D>>> {
+  const { type, attributes, relationships } = existingBlock;
+
+  const itemType = await schemaRepository.getRawItemTypeById(
+    existingBlock.relationships.item_type.data.id,
+  );
+
+  const newBlock = {
+    type,
+    relationships,
+    attributes,
+  } as NewBlockInRequest;
+
+  const fields = await schemaRepository.getRawItemTypeFields(itemType);
+
+  for (const field of fields) {
+    newBlock.attributes[field.attributes.api_key] =
+      await mapBlocksInNonLocalizedFieldValue(
+        newBlock.attributes[field.attributes.api_key],
+        field.attributes.field_type,
+        schemaRepository,
+        (block, path) => {
+          if (typeof block === 'string') {
+            throw new Error(
+              `Block cannot be duplicated as it contains nested block at ${path.join('.')} that is expressed as ID (${block}) instead of full object!`,
+            );
+          }
+
+          const { id, meta, ...blockWithoutIdAndMeta } = block;
+
+          return blockWithoutIdAndMeta as NewBlockInRequest;
+        },
+      );
+  }
+
+  return newBlock as NewBlockInRequest<NoInfer<D>>;
+}

package/src/utilities/inspectItem.ts

@@ -1,79 +1,81 @@
+import * as Utils from '@datocms/rest-client-utils';
 import {
   type TreeNode,
   formatAsTree,
   inspectionTreeNodes,
 } from 'datocms-structured-text-utils';
 import {
-  type BlockItemInARequest,
+  type BlockInRequest,
   type BooleanFieldValue,
   type ColorFieldValue,
   type DateFieldValue,
   type DateTimeFieldValue,
   type FileFieldValue,
-  type FileFieldValueAsRequest,
+  type FileFieldValueInRequest,
   type FloatFieldValue,
   type GalleryFieldValue,
-  type GalleryFieldValueAsRequest,
+  type GalleryFieldValueInRequest,
   type IntegerFieldValue,
   type JsonFieldValue,
   type LatLonFieldValue,
   type LinkFieldValue,
   type LinksFieldValue,
-  type NewBlockInARequest,
+  type NewBlockInRequest,
   type RichTextFieldValue,
-  type RichTextFieldValueAsRequest,
-  type RichTextFieldValueWithNestedBlocks,
+  type RichTextFieldValueInNestedResponse,
+  type RichTextFieldValueInRequest,
   type SeoFieldValue,
   type SingleBlockFieldValue,
-  type SingleBlockFieldValueAsRequest,
-  type SingleBlockFieldValueWithNestedBlocks,
+  type SingleBlockFieldValueInNestedResponse,
+  type SingleBlockFieldValueInRequest,
   type SlugFieldValue,
   type StringFieldValue,
   type StructuredTextFieldValue,
-  type StructuredTextFieldValueAsRequest,
-  type StructuredTextFieldValueWithNestedBlocks,
+  type StructuredTextFieldValueInNestedResponse,
+  type StructuredTextFieldValueInRequest,
   type TextFieldValue,
-  type UpdatedBlockInARequest,
+  type UpdatedBlockInRequest,
   type VideoFieldValue,
   isBooleanFieldValue,
   isColorFieldValue,
   isDateFieldValue,
   isDateTimeFieldValue,
   isFileFieldValue,
-  isFileFieldValueAsRequest,
+  isFileFieldValueInRequest,
   isFloatFieldValue,
   isGalleryFieldValue,
-  isGalleryFieldValueAsRequest,
+  isGalleryFieldValueInRequest,
   isIntegerFieldValue,
   isJsonFieldValue,
   isLatLonFieldValue,
   isLinkFieldValue,
   isLinksFieldValue,
   isRichTextFieldValue,
-  isRichTextFieldValueAsRequest,
-  isRichTextFieldValueWithNestedBlocks,
+  isRichTextFieldValueInNestedResponse,
+  isRichTextFieldValueInRequest,
   isSeoFieldValue,
   isSingleBlockFieldValue,
-  isSingleBlockFieldValueAsRequest,
-  isSingleBlockFieldValueWithNestedBlocks,
+  isSingleBlockFieldValueInNestedResponse,
+  isSingleBlockFieldValueInRequest,
   isSlugFieldValue,
   isStringFieldValue,
   isStructuredTextFieldValue,
-  isStructuredTextFieldValueAsRequest,
-  isStructuredTextFieldValueWithNestedBlocks,
+  isStructuredTextFieldValueInNestedResponse,
+  isStructuredTextFieldValueInRequest,
   isTextFieldValue,
   isVideoFieldValue,
 } from '../fieldTypes';
+import { Item as ItemResource } from '../generated/resources';
 
-import { type ApiTypes, type RawApiTypes, buildBlockRecord } from '../index';
+import type { ApiTypes, RawApiTypes } from '../index';
 import type { LocalizedFieldValue } from './normalizedFieldValues';
 import { isLocalizedFieldValue } from './normalizedFieldValues';
 
 type Item =
   | ApiTypes.Item
   | RawApiTypes.Item
-  | NewBlockInARequest
-  | UpdatedBlockInARequest
+  | NewBlockInRequest
+  | UpdatedBlockInRequest
   | RawApiTypes.ItemCreateSchema
   | RawApiTypes.ItemUpdateSchema
   | ApiTypes.ItemCreateSchema
@@ -95,9 +97,9 @@ const fieldTypeHandlers: FieldTypeHandler[] = [
   { guard: isDateFieldValue, inspect: dateInspectionTreeNodes },
   { guard: isDateTimeFieldValue, inspect: dateTimeInspectionTreeNodes },
   { guard: isGalleryFieldValue, inspect: galleryInspectionTreeNodes },
-  { guard: isGalleryFieldValueAsRequest, inspect: galleryInspectionTreeNodes },
+  { guard: isGalleryFieldValueInRequest, inspect: galleryInspectionTreeNodes },
   { guard: isFileFieldValue, inspect: fileInspectionTreeNodes },
-  { guard: isFileFieldValueAsRequest, inspect: fileInspectionTreeNodes },
+  { guard: isFileFieldValueInRequest, inspect: fileInspectionTreeNodes },
   { guard: isJsonFieldValue, inspect: jsonInspectionTreeNodes },
   { guard: isSlugFieldValue, inspect: slugInspectionTreeNodes },
   { guard: isStringFieldValue, inspect: stringInspectionTreeNodes },
@@ -112,29 +114,29 @@ const fieldTypeHandlers: FieldTypeHandler[] = [
     inspect: structuredTextInspectionTreeNodes,
   },
   {
-    guard: isStructuredTextFieldValueAsRequest,
+    guard: isStructuredTextFieldValueInRequest,
     inspect: structuredTextInspectionTreeNodes,
   },
   {
-    guard: isStructuredTextFieldValueWithNestedBlocks,
+    guard: isStructuredTextFieldValueInNestedResponse,
     inspect: structuredTextInspectionTreeNodes,
   },
   { guard: isSingleBlockFieldValue, inspect: singleBlockInspectionTreeNodes },
   {
-    guard: isSingleBlockFieldValueAsRequest,
+    guard: isSingleBlockFieldValueInRequest,
     inspect: singleBlockInspectionTreeNodes,
   },
   {
-    guard: isSingleBlockFieldValueWithNestedBlocks,
+    guard: isSingleBlockFieldValueInNestedResponse,
     inspect: singleBlockInspectionTreeNodes,
   },
   { guard: isRichTextFieldValue, inspect: richTextInspectionTreeNodes },
   {
-    guard: isRichTextFieldValueAsRequest,
+    guard: isRichTextFieldValueInRequest,
     inspect: richTextInspectionTreeNodes,
   },
   {
-    guard: isRichTextFieldValueWithNestedBlocks,
+    guard: isRichTextFieldValueInNestedResponse,
     inspect: richTextInspectionTreeNodes,
   },
 ];
@@ -208,14 +210,20 @@ function inspectFieldValue(
   return `UNKNOWN: ${JSON.stringify(value)}`;
 }
 
-function extractAttributes(item: Item): Record<string, unknown> {
+function normalizeItem(item: any): RawApiTypes.Item {
   if ('attributes' in item) {
-    return item.attributes as Record<string, unknown>;
+    return item;
   }
 
-  const serializedItem = buildBlockRecord(item);
-  const { __itemTypeId, ...rest } = serializedItem.attributes;
-  return rest;
+  const { __itemTypeId, ...itemWithoutItemTypeId } = item;
+
+  return Utils.serializeRequestBody<{
+    data: RawApiTypes.Item;
+  }>(itemWithoutItemTypeId, {
+    type: ItemResource.TYPE,
+    attributes: '*',
+    relationships: ['item_type', 'creator'],
+  }).data;
 }
 
 export type InspectItemOptions = {
@@ -232,8 +240,10 @@ function itemInspectionTreeNodes(
 ): TreeNode {
   let itemTypeId: string | undefined;
 
-  if ('relationships' in item && item.relationships) {
-    const relationships = item.relationships as any;
+  const normalizedItem = normalizeItem(item);
+
+  if ('relationships' in normalizedItem && normalizedItem.relationships) {
+    const relationships = normalizedItem.relationships as any;
     if (relationships.item_type?.data?.id) {
       itemTypeId = relationships.item_type.data.id;
     }
@@ -241,7 +251,7 @@ function itemInspectionTreeNodes(
 
   const rootLabel = [
     'Item',
-    'id' in item ? JSON.stringify(item.id) : null,
+    'id' in item ? JSON.stringify(normalizedItem.id) : null,
     itemTypeId ? `(item_type: ${JSON.stringify(itemTypeId)})` : null,
   ]
     .filter(Boolean)
@@ -249,11 +259,13 @@ function itemInspectionTreeNodes(
 
   const nodes: TreeNode[] = [];
 
-  for (const [attributeName, attributeValue] of Object.entries(
-    extractAttributes(item),
-  )) {
-    const inspectResult = inspectFieldValue(attributeValue, options);
-    nodes.push(createChildNode(attributeName, inspectResult));
+  if ('attributes' in normalizedItem) {
+    for (const [attributeName, attributeValue] of Object.entries(
+      normalizedItem.attributes,
+    )) {
+      const inspectResult = inspectFieldValue(attributeValue, options);
+      nodes.push(createChildNode(attributeName, inspectResult));
+    }
   }
 
   return {
@@ -265,13 +277,13 @@ function itemInspectionTreeNodes(
 function structuredTextInspectionTreeNodes(
   value:
     | StructuredTextFieldValue
-    | StructuredTextFieldValueAsRequest
-    | StructuredTextFieldValueWithNestedBlocks,
+    | StructuredTextFieldValueInRequest
+    | StructuredTextFieldValueInNestedResponse,
   options?: InspectItemOptions,
 ) {
   if (value === null) return 'null';
 
-  return inspectionTreeNodes<BlockItemInARequest, BlockItemInARequest>(value, {
+  return inspectionTreeNodes<BlockInRequest, BlockInRequest>(value, {
     maxWidth: options?.maxWidth || 80,
     blockFormatter: (block, maxWidth) => {
       if (typeof block === 'string') {
@@ -286,8 +298,8 @@ function structuredTextInspectionTreeNodes(
 function singleBlockInspectionTreeNodes(
   value:
     | SingleBlockFieldValue
-    | SingleBlockFieldValueAsRequest
-    | SingleBlockFieldValueWithNestedBlocks,
+    | SingleBlockFieldValueInRequest
+    | SingleBlockFieldValueInNestedResponse,
   options?: InspectItemOptions,
 ) {
   if (value === null) return 'null';
@@ -298,8 +310,8 @@ function singleBlockInspectionTreeNodes(
 function richTextInspectionTreeNodes(
   value:
     | RichTextFieldValue
-    | RichTextFieldValueAsRequest
-    | RichTextFieldValueWithNestedBlocks,
+    | RichTextFieldValueInRequest
+    | RichTextFieldValueInNestedResponse,
   options?: InspectItemOptions,
 ): string | TreeNode[] {
   if (value === null) return 'null';
@@ -342,7 +354,7 @@ function dateTimeInspectionTreeNodes(value: DateTimeFieldValue): string {
 }
 
 function fileInspectionTreeNodes(
-  value: FileFieldValue | FileFieldValueAsRequest,
+  value: FileFieldValue | FileFieldValueInRequest,
   options?: InspectItemOptions,
 ): string | TreeNode[] {
   if (value === null) return 'null';
@@ -384,7 +396,7 @@ function floatInspectionTreeNodes(value: FloatFieldValue): string {
 }
 
 function galleryInspectionTreeNodes(
-  value: GalleryFieldValue | GalleryFieldValueAsRequest,
+  value: GalleryFieldValue | GalleryFieldValueInRequest,
   options?: InspectItemOptions,
 ): string | TreeNode[] {
   if (!value || value.length === 0) return '[]';