@datocms/cma-client 5.1.12 → 5.1.14

package/dist/types/utilities/buildBlockRecord.d.ts

@@ -1,6 +1,14 @@
 import type { NewBlockInRequest } from '../fieldTypes';
 import type * as ApiTypes from '../generated/ApiTypes';
-import type { ItemTypeDefinition } from './itemDefinition';
+import type { ItemTypeDefinition, ToItemAttributesInRequest } from './itemDefinition';
 type NoInfer<T> = [T][T extends any ? 0 : never];
-export declare function buildBlockRecord<D extends ItemTypeDefinition = ItemTypeDefinition>(body: ApiTypes.ItemUpdateSchema<NoInfer<D>>): NewBlockInRequest<NoInfer<D>>;
+type UpdateOrCreateBlockRecordSchema<D extends ItemTypeDefinition = ItemTypeDefinition> = {
+    id?: ApiTypes.ItemIdentity;
+    type?: ApiTypes.ItemType1;
+    item_type: ApiTypes.ItemTypeData<D>;
+    meta?: ApiTypes.ItemUpdateSchema['meta'];
+    creator?: ApiTypes.ItemUpdateSchema['creator'];
+    __itemTypeId?: D['itemTypeId'];
+} & ToItemAttributesInRequest<D>;
+export declare function buildBlockRecord<D extends ItemTypeDefinition = ItemTypeDefinition>(body: UpdateOrCreateBlockRecordSchema<NoInfer<D>>): NewBlockInRequest<NoInfer<D>>;
 export {};

package/dist/types/utilities/schemaRepository.d.ts

@@ -24,6 +24,14 @@ interface GenericClient {
             data: RawApiTypes.Plugin[];
         }>;
     };
+    site: {
+        rawFind(params: {
+            include: string;
+        }): Promise<{
+            data: any;
+            included?: Array<RawApiTypes.ItemType | RawApiTypes.Field | any>;
+        }>;
+    };
 }
 /**
  * Repository for DatoCMS schema entities including item types, fields, and plugins.
@@ -244,5 +252,37 @@ export declare class SchemaRepository {
      * @throws Error if the plugin is not found
      */
     getRawPluginByPackageName(packageName: string): Promise<RawApiTypes.Plugin>;
+    /**
+     * Prefetches all models and their fields in a single optimized API call.
+     * This method populates the internal caches for both item types and fields,
+     * making subsequent lookups very fast without additional API calls.
+     *
+     * This is more efficient than lazy loading when you know you'll need access
+     * to multiple models and fields, as it reduces the number of API requests
+     * from potentially dozens down to just one.
+     *
+     * @returns Promise that resolves when all data has been fetched and cached
+     */
+    prefetchAllModelsAndFields(): Promise<void>;
+    /**
+     * Gets all models that directly or indirectly embed the given block models.
+     * This method recursively traverses the schema to find all models that reference
+     * the provided blocks, either directly through block fields or indirectly through
+     * other block models that reference them.
+     *
+     * @param blocks - Array of block models to find references to
+     * @returns Promise that resolves to array of models that embed these blocks
+     */
+    getRawModelsEmbeddingBlocks(blocks: Array<ApiTypes.ItemType | RawApiTypes.ItemType>): Promise<Array<RawApiTypes.ItemType>>;
+    /**
+     * Gets all models that directly or indirectly embed the given block models.
+     * This method recursively traverses the schema to find all models that reference
+     * the provided blocks, either directly through block fields or indirectly through
+     * other block models that reference them.
+     *
+     * @param blocks - Array of block models to find references to
+     * @returns Promise that resolves to array of models that embed these blocks
+     */
+    getModelsEmbeddingBlocks(blocks: Array<ApiTypes.ItemType | RawApiTypes.ItemType>): Promise<Array<ApiTypes.ItemType>>;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datocms/cma-client",
-  "version": "5.1.12",
+  "version": "5.1.14",
   "description": "JS client for DatoCMS REST Content Management API",
   "keywords": [
     "datocms",
@@ -37,13 +37,13 @@
     "url": "https://github.com/datocms/js-rest-api-clients/issues"
   },
   "dependencies": {
-    "@datocms/rest-client-utils": "^5.1.6",
+    "@datocms/rest-client-utils": "^5.1.13",
     "datocms-structured-text-utils": "^5.1.4",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@datocms/dashboard-client": "^5.1.12",
+    "@datocms/dashboard-client": "^5.1.13",
     "@types/uuid": "^9.0.7"
   },
-  "gitHead": "20ef29ad11049203a14461a9565e0f7833593867"
+  "gitHead": "267e2d5a5dbab1bf3cec144445724bcec49ae7e3"
 }

package/src/fieldTypes/schema.ts

@@ -93,7 +93,7 @@ type LocalizedFieldAttributesForFieldType<
 > & {
   field_type: FieldType;
   localized: true;
-  default_value: FieldValue | Record<string, FieldValue>;
+  default_value: Record<string, FieldValue>;
   validators: FieldValidators;
   appearance: FieldAppearanceConfig<FieldAppearance>;
 };

package/src/fieldTypes/single_block.ts

@@ -68,7 +68,7 @@ export type UpdatedBlockInRequest<
   __itemTypeId?: D['itemTypeId'];
   type: RawApiTypes.ItemType1;
   id: RawApiTypes.ItemIdentity;
-  relationships?: RawApiTypes.ItemRelationships<D>;
+  relationships: RawApiTypes.ItemRelationships<D>;
   meta?: RawApiTypes.ItemMeta;
   attributes: ToItemAttributesInRequest<D>;
 };

package/src/generated/ApiTypes.ts

@@ -7412,6 +7412,7 @@ export type ItemValidateExistingSchema<
     | UserData
     | SsoUserData
     | OrganizationData;
+  __itemTypeId?: D['itemTypeId'];
 } & ToItemAttributesInRequest<D>;
 /**
  * This interface was referenced by `Item`'s JSON-Schema
@@ -7428,6 +7429,7 @@ export type ItemValidateNewSchema<
     | UserData
     | SsoUserData
     | OrganizationData;
+  __itemTypeId?: D['itemTypeId'];
 } & ToItemAttributesInRequest<D>;
 /**
  * This interface was referenced by `Item`'s JSON-Schema
@@ -7490,6 +7492,7 @@ export type ItemCreateSchema<
      */
     current_version?: string;
   };
+  __itemTypeId?: D['itemTypeId'];
 } & ToItemAttributesInRequest<D>;
 /**
  * This interface was referenced by `Item`'s JSON-Schema
@@ -7564,6 +7567,7 @@ export type ItemUpdateSchema<
      */
     has_children?: null | boolean;
   };
+  __itemTypeId?: D['itemTypeId'];
 } & ToItemAttributesInRequest<D>;
 /**
  * Information about the record

package/src/generated/Client.ts

@@ -147,7 +147,7 @@ export class Client {
       ...this.config,
       ...options,
       logFn: this.config.logFn || console.log,
-      userAgent: '@datocms/cma-client v5.1.12',
+      userAgent: '@datocms/cma-client v5.1.14',
       baseUrl: this.baseUrl,
       preCallStack: new Error().stack,
       extraHeaders: {

package/src/generated/RawApiTypes.ts

@@ -7133,6 +7133,7 @@ export type ItemValidateExistingSchema<
           | OrganizationData;
       };
     };
+    __itemTypeId?: D['itemTypeId'];
   };
 };
 /**
@@ -7167,6 +7168,7 @@ export type ItemValidateNewSchema<
           | OrganizationData;
       };
     };
+    __itemTypeId?: D['itemTypeId'];
   };
 };
 /**
@@ -7247,6 +7249,7 @@ export type ItemCreateSchema<
           | OrganizationData;
       };
     };
+    __itemTypeId?: D['itemTypeId'];
   };
 };
 /**
@@ -7378,6 +7381,7 @@ export type ItemUpdateSchema<
           | OrganizationData;
       };
     };
+    __itemTypeId?: D['itemTypeId'];
   };
 };
 /**

package/src/utilities/buildBlockRecord.ts

@@ -2,13 +2,29 @@ import * as Utils from '@datocms/rest-client-utils';
 import type { NewBlockInRequest } from '../fieldTypes';
 import type * as ApiTypes from '../generated/ApiTypes';
 import { Item } from '../generated/resources';
-import type { ItemTypeDefinition } from './itemDefinition';
+import type {
+  ItemTypeDefinition,
+  ToItemAttributesInRequest,
+} from './itemDefinition';
 
 type NoInfer<T> = [T][T extends any ? 0 : never];
 
+type UpdateOrCreateBlockRecordSchema<
+  D extends ItemTypeDefinition = ItemTypeDefinition,
+> = {
+  id?: ApiTypes.ItemIdentity;
+  type?: ApiTypes.ItemType1;
+  item_type: ApiTypes.ItemTypeData<D>;
+  meta?: ApiTypes.ItemUpdateSchema['meta'];
+  creator?: ApiTypes.ItemUpdateSchema['creator'];
+  __itemTypeId?: D['itemTypeId'];
+} & ToItemAttributesInRequest<D>;
+
 export function buildBlockRecord<
   D extends ItemTypeDefinition = ItemTypeDefinition,
->(body: ApiTypes.ItemUpdateSchema<NoInfer<D>>): NewBlockInRequest<NoInfer<D>> {
+>(
+  body: UpdateOrCreateBlockRecordSchema<NoInfer<D>>,
+): NewBlockInRequest<NoInfer<D>> {
   return Utils.serializeRequestBody<{
     data: NewBlockInRequest<NoInfer<D>>;
   }>(body, {

package/src/utilities/duplicateBlockRecord.ts

@@ -14,13 +14,14 @@ export async function duplicateBlockRecord<
   existingBlock: ItemWithOptionalIdAndMeta<NoInfer<D>>,
   schemaRepository: SchemaRepository,
 ): Promise<NewBlockInRequest<NoInfer<D>>> {
-  const { type, attributes, relationships } = existingBlock;
+  const { __itemTypeId, type, attributes, relationships } = existingBlock;
 
   const itemType = await schemaRepository.getRawItemTypeById(
     existingBlock.relationships.item_type.data.id,
   );
 
   const newBlock = {
+    __itemTypeId,
     type,
     relationships,
     attributes,

package/src/utilities/schemaRepository.ts

@@ -1,6 +1,7 @@
 import { deserializeResponseBody } from '@datocms/rest-client-utils';
 import type * as ApiTypes from '../generated/ApiTypes';
 import type * as RawApiTypes from '../generated/RawApiTypes';
+import { blockModelIdsReferencedInField } from './fieldsContainingReferences';
 
 interface GenericClient {
   itemTypes: {
@@ -16,6 +17,12 @@ interface GenericClient {
   plugins: {
     rawList(): Promise<{ data: RawApiTypes.Plugin[] }>;
   };
+  site: {
+    rawFind(params: { include: string }): Promise<{
+      data: any;
+      included?: Array<RawApiTypes.ItemType | RawApiTypes.Field | any>;
+    }>;
+  };
 }
 
 /**
@@ -437,4 +444,138 @@ export class SchemaRepository {
 
     return plugin;
   }
+
+  /**
+   * Prefetches all models and their fields in a single optimized API call.
+   * This method populates the internal caches for both item types and fields,
+   * making subsequent lookups very fast without additional API calls.
+   *
+   * This is more efficient than lazy loading when you know you'll need access
+   * to multiple models and fields, as it reduces the number of API requests
+   * from potentially dozens down to just one.
+   *
+   * @returns Promise that resolves when all data has been fetched and cached
+   */
+  async prefetchAllModelsAndFields(): Promise<void> {
+    const { included } = await this.client.site.rawFind({
+      include: 'item_types,item_types.fields',
+    });
+
+    if (!included) {
+      throw new Error('This should not happen');
+    }
+
+    const allItemTypes = included.filter(
+      (item): item is RawApiTypes.ItemType => item.type === 'item_type',
+    );
+    const allFields = included.filter(
+      (item): item is RawApiTypes.Field => item.type === 'field',
+    );
+
+    // Populate item types caches
+    this.itemTypesPromise = Promise.resolve(allItemTypes);
+    for (const itemType of allItemTypes) {
+      this.itemTypesByApiKey.set(itemType.attributes.api_key, itemType);
+      this.itemTypesById.set(itemType.id, itemType);
+    }
+
+    // Group fields by item type and populate fields cache
+    const fieldsByItemTypeId = new Map<string, RawApiTypes.Field[]>();
+    for (const field of allFields) {
+      const itemTypeId = field.relationships.item_type.data.id;
+      if (!fieldsByItemTypeId.has(itemTypeId)) {
+        fieldsByItemTypeId.set(itemTypeId, []);
+      }
+      fieldsByItemTypeId.get(itemTypeId)!.push(field);
+    }
+
+    // Populate the fields cache
+    for (const [itemTypeId, fields] of fieldsByItemTypeId) {
+      this.fieldsByItemType.set(itemTypeId, fields);
+    }
+  }
+
+  /**
+   * Gets all models that directly or indirectly embed the given block models.
+   * This method recursively traverses the schema to find all models that reference
+   * the provided blocks, either directly through block fields or indirectly through
+   * other block models that reference them.
+   *
+   * @param blocks - Array of block models to find references to
+   * @returns Promise that resolves to array of models that embed these blocks
+   */
+  async getRawModelsEmbeddingBlocks(
+    blocks: Array<ApiTypes.ItemType | RawApiTypes.ItemType>,
+  ): Promise<Array<RawApiTypes.ItemType>> {
+    await this.prefetchAllModelsAndFields();
+
+    const allItemTypes = await this.getAllRawItemTypes();
+    const blockIds = new Set(blocks.map((block) => block.id));
+    const embeddingModels: Array<RawApiTypes.ItemType> = [];
+
+    // Helper function to check if a model points to any of the target blocks
+    const modelPointsToBlocks = async (
+      itemType: RawApiTypes.ItemType,
+      alreadyExplored: Set<string> = new Set(),
+    ): Promise<boolean> => {
+      if (alreadyExplored.has(itemType.id)) {
+        return false;
+      }
+
+      alreadyExplored.add(itemType.id);
+
+      const fields = await this.getRawItemTypeFields(itemType);
+
+      for (const field of fields) {
+        const referencedBlockIds = blockModelIdsReferencedInField(field);
+
+        // Check if this field directly references any of our target blocks
+        if (referencedBlockIds.some((id) => blockIds.has(id))) {
+          return true;
+        }
+
+        // Check if this field references other block models that might transitively reference our targets
+        const referencedBlocks = referencedBlockIds.map(
+          (id) => allItemTypes.find((it) => it.id === id)!,
+        );
+
+        for (const linkedBlock of referencedBlocks) {
+          if (
+            await modelPointsToBlocks(linkedBlock, new Set(alreadyExplored))
+          ) {
+            return true;
+          }
+        }
+      }
+
+      return false;
+    };
+
+    // Check each model to see if it embeds any of the target blocks
+    for (const itemType of allItemTypes) {
+      if (await modelPointsToBlocks(itemType)) {
+        embeddingModels.push(itemType);
+      }
+    }
+
+    return embeddingModels;
+  }
+
+  /**
+   * Gets all models that directly or indirectly embed the given block models.
+   * This method recursively traverses the schema to find all models that reference
+   * the provided blocks, either directly through block fields or indirectly through
+   * other block models that reference them.
+   *
+   * @param blocks - Array of block models to find references to
+   * @returns Promise that resolves to array of models that embed these blocks
+   */
+  async getModelsEmbeddingBlocks(
+    blocks: Array<ApiTypes.ItemType | RawApiTypes.ItemType>,
+  ): Promise<Array<ApiTypes.ItemType>> {
+    const rawResult = await this.getRawModelsEmbeddingBlocks(blocks);
+    return deserializeResponseBody<ApiTypes.ItemType[]>({
+      data: rawResult,
+    });
+  }
 }