@datocms/cma-client 6.0.0 → 6.1.3

package/dist/esm/utilities/schemaRepository.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { deserializeResponseBody } from '@datocms/rest-client-utils';
 import { blockModelIdsReferencedInField, modelIdsReferencedInField, } from './fieldsContainingReferences.js';
 /**
@@ -99,87 +90,73 @@ export class SchemaRepository {
      * This method is called lazily and caches the result for subsequent calls.
      * @returns Promise that resolves to an array of item types
      */
-    loadItemTypes() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.itemTypesPromise) {
-                this.itemTypesPromise = (() => __awaiter(this, void 0, void 0, function* () {
-                    const { data: itemTypes } = yield this.client.itemTypes.rawList();
-                    // Populate the lookup maps
-                    for (const itemType of itemTypes) {
-                        this.itemTypesByApiKey.set(itemType.attributes.api_key, itemType);
-                        this.itemTypesById.set(itemType.id, itemType);
-                    }
-                    return itemTypes;
-                }))();
-            }
-            return this.itemTypesPromise;
-        });
+    async loadItemTypes() {
+        if (!this.itemTypesPromise) {
+            this.itemTypesPromise = (async () => {
+                const { data: itemTypes } = await this.client.itemTypes.rawList();
+                // Populate the lookup maps
+                for (const itemType of itemTypes) {
+                    this.itemTypesByApiKey.set(itemType.attributes.api_key, itemType);
+                    this.itemTypesById.set(itemType.id, itemType);
+                }
+                return itemTypes;
+            })();
+        }
+        return this.itemTypesPromise;
     }
     /**
      * Gets all item types from the DatoCMS project.
      * @returns Promise that resolves to an array of all item types
      */
-    getAllItemTypes() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getAllRawItemTypes();
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getAllItemTypes() {
+        const rawResult = await this.getAllRawItemTypes();
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
      * Gets all item types from the DatoCMS project.
      * @returns Promise that resolves to an array of all item types
      */
-    getAllRawItemTypes() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const itemTypes = yield this.loadItemTypes();
-            return itemTypes;
-        });
+    async getAllRawItemTypes() {
+        const itemTypes = await this.loadItemTypes();
+        return itemTypes;
     }
     /**
      * Gets all item types that are models (not modular blocks).
      * @returns Promise that resolves to an array of model item types
      */
-    getAllModels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getAllRawModels();
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getAllModels() {
+        const rawResult = await this.getAllRawModels();
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
      * Gets all item types that are models (not modular blocks).
      * @returns Promise that resolves to an array of model item types
      */
-    getAllRawModels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const itemTypes = yield this.loadItemTypes();
-            return itemTypes.filter((it) => !it.attributes.modular_block);
-        });
+    async getAllRawModels() {
+        const itemTypes = await this.loadItemTypes();
+        return itemTypes.filter((it) => !it.attributes.modular_block);
     }
     /**
      * Gets all item types that are modular blocks.
      * @returns Promise that resolves to an array of block model item types
      */
-    getAllBlockModels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getAllRawBlockModels();
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getAllBlockModels() {
+        const rawResult = await this.getAllRawBlockModels();
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
      * Gets all item types that are modular blocks.
      * @returns Promise that resolves to an array of block model item types
      */
-    getAllRawBlockModels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const itemTypes = yield this.loadItemTypes();
-            return itemTypes.filter((it) => it.attributes.modular_block);
-        });
+    async getAllRawBlockModels() {
+        const itemTypes = await this.loadItemTypes();
+        return itemTypes.filter((it) => it.attributes.modular_block);
     }
     /**
      * Gets an item type by its API key.
@@ -187,12 +164,10 @@ export class SchemaRepository {
      * @returns Promise that resolves to the item type
      * @throws Error if the item type is not found
      */
-    getItemTypeByApiKey(apiKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getRawItemTypeByApiKey(apiKey);
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getItemTypeByApiKey(apiKey) {
+        const rawResult = await this.getRawItemTypeByApiKey(apiKey);
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
@@ -201,15 +176,13 @@ export class SchemaRepository {
      * @returns Promise that resolves to the item type
      * @throws Error if the item type is not found
      */
-    getRawItemTypeByApiKey(apiKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.loadItemTypes();
-            const itemType = this.itemTypesByApiKey.get(apiKey);
-            if (!itemType) {
-                throw new Error(`Item type with API key '${apiKey}' not found`);
-            }
-            return itemType;
-        });
+    async getRawItemTypeByApiKey(apiKey) {
+        await this.loadItemTypes();
+        const itemType = this.itemTypesByApiKey.get(apiKey);
+        if (!itemType) {
+            throw new Error(`Item type with API key '${apiKey}' not found`);
+        }
+        return itemType;
     }
     /**
      * Gets an item type by its ID.
@@ -217,12 +190,10 @@ export class SchemaRepository {
      * @returns Promise that resolves to the item type
      * @throws Error if the item type is not found
      */
-    getItemTypeById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getRawItemTypeById(id);
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getItemTypeById(id) {
+        const rawResult = await this.getRawItemTypeById(id);
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
@@ -231,15 +202,13 @@ export class SchemaRepository {
      * @returns Promise that resolves to the item type
      * @throws Error if the item type is not found
      */
-    getRawItemTypeById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.loadItemTypes();
-            const itemType = this.itemTypesById.get(id);
-            if (!itemType) {
-                throw new Error(`Item type with ID '${id}' not found`);
-            }
-            return itemType;
-        });
+    async getRawItemTypeById(id) {
+        await this.loadItemTypes();
+        const itemType = this.itemTypesById.get(id);
+        if (!itemType) {
+            throw new Error(`Item type with ID '${id}' not found`);
+        }
+        return itemType;
     }
     /**
      * Gets all fields for a given item type.
@@ -247,12 +216,10 @@ export class SchemaRepository {
      * @param itemType - The item type to get fields for
      * @returns Promise that resolves to an array of fields
      */
-    getItemTypeFields(itemType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getRawItemTypeFields(itemType);
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getItemTypeFields(itemType) {
+        const rawResult = await this.getRawItemTypeFields(itemType);
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
@@ -261,18 +228,16 @@ export class SchemaRepository {
      * @param itemType - The item type to get fields for
      * @returns Promise that resolves to an array of fields
      */
-    getRawItemTypeFields(itemType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if we already have the fields cached
-            const cachedFields = this.fieldsByItemType.get(itemType.id);
-            if (cachedFields) {
-                return cachedFields;
-            }
-            // Fetch and cache the fields
-            const { data: fields } = yield this.client.fields.rawList(itemType.id);
-            this.fieldsByItemType.set(itemType.id, fields);
-            return fields;
-        });
+    async getRawItemTypeFields(itemType) {
+        // Check if we already have the fields cached
+        const cachedFields = this.fieldsByItemType.get(itemType.id);
+        if (cachedFields) {
+            return cachedFields;
+        }
+        // Fetch and cache the fields
+        const { data: fields } = await this.client.fields.rawList(itemType.id);
+        this.fieldsByItemType.set(itemType.id, fields);
+        return fields;
     }
     /**
      * Gets all fieldsets for a given item type.
@@ -280,12 +245,10 @@ export class SchemaRepository {
      * @param itemType - The item type to get fieldsets for
      * @returns Promise that resolves to an array of fieldsets
      */
-    getItemTypeFieldsets(itemType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getRawItemTypeFieldsets(itemType);
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getItemTypeFieldsets(itemType) {
+        const rawResult = await this.getRawItemTypeFieldsets(itemType);
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
@@ -294,63 +257,55 @@ export class SchemaRepository {
      * @param itemType - The item type to get fieldsets for
      * @returns Promise that resolves to an array of fieldsets
      */
-    getRawItemTypeFieldsets(itemType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if we already have the fieldsets cached
-            const cachedFieldsets = this.fieldsetsByItemType.get(itemType.id);
-            if (cachedFieldsets) {
-                return cachedFieldsets;
-            }
-            // Fetch and cache the fieldsets
-            const { data: fieldsets } = yield this.client.fieldsets.rawList(itemType.id);
-            this.fieldsetsByItemType.set(itemType.id, fieldsets);
-            return fieldsets;
-        });
+    async getRawItemTypeFieldsets(itemType) {
+        // Check if we already have the fieldsets cached
+        const cachedFieldsets = this.fieldsetsByItemType.get(itemType.id);
+        if (cachedFieldsets) {
+            return cachedFieldsets;
+        }
+        // Fetch and cache the fieldsets
+        const { data: fieldsets } = await this.client.fieldsets.rawList(itemType.id);
+        this.fieldsetsByItemType.set(itemType.id, fieldsets);
+        return fieldsets;
     }
     /**
      * Loads and caches all plugins from the DatoCMS API.
      * This method is called lazily and caches the result for subsequent calls.
      * @returns Promise that resolves to an array of plugins
      */
-    loadPlugins() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.pluginsPromise) {
-                this.pluginsPromise = (() => __awaiter(this, void 0, void 0, function* () {
-                    const { data: plugins } = yield this.client.plugins.rawList();
-                    // Populate the lookup maps
-                    for (const plugin of plugins) {
-                        this.pluginsById.set(plugin.id, plugin);
-                        if (plugin.attributes.package_name) {
-                            this.pluginsByPackageName.set(plugin.attributes.package_name, plugin);
-                        }
+    async loadPlugins() {
+        if (!this.pluginsPromise) {
+            this.pluginsPromise = (async () => {
+                const { data: plugins } = await this.client.plugins.rawList();
+                // Populate the lookup maps
+                for (const plugin of plugins) {
+                    this.pluginsById.set(plugin.id, plugin);
+                    if (plugin.attributes.package_name) {
+                        this.pluginsByPackageName.set(plugin.attributes.package_name, plugin);
                     }
-                    return plugins;
-                }))();
-            }
-            return this.pluginsPromise;
-        });
+                }
+                return plugins;
+            })();
+        }
+        return this.pluginsPromise;
     }
     /**
      * Gets all plugins from the DatoCMS project.
      * @returns Promise that resolves to an array of all plugins
      */
-    getAllPlugins() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getAllRawPlugins();
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getAllPlugins() {
+        const rawResult = await this.getAllRawPlugins();
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
      * Gets all plugins from the DatoCMS project.
      * @returns Promise that resolves to an array of all plugins
      */
-    getAllRawPlugins() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const plugins = yield this.loadPlugins();
-            return plugins;
-        });
+    async getAllRawPlugins() {
+        const plugins = await this.loadPlugins();
+        return plugins;
     }
     /**
      * Gets a plugin by its ID.
@@ -358,12 +313,10 @@ export class SchemaRepository {
      * @returns Promise that resolves to the plugin
      * @throws Error if the plugin is not found
      */
-    getPluginById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getRawPluginById(id);
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getPluginById(id) {
+        const rawResult = await this.getRawPluginById(id);
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
@@ -372,15 +325,13 @@ export class SchemaRepository {
      * @returns Promise that resolves to the plugin
      * @throws Error if the plugin is not found
      */
-    getRawPluginById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.loadPlugins();
-            const plugin = this.pluginsById.get(id);
-            if (!plugin) {
-                throw new Error(`Plugin with ID '${id}' not found`);
-            }
-            return plugin;
-        });
+    async getRawPluginById(id) {
+        await this.loadPlugins();
+        const plugin = this.pluginsById.get(id);
+        if (!plugin) {
+            throw new Error(`Plugin with ID '${id}' not found`);
+        }
+        return plugin;
     }
     /**
      * Gets a plugin by its package name.
@@ -388,12 +339,10 @@ export class SchemaRepository {
      * @returns Promise that resolves to the plugin
      * @throws Error if the plugin is not found
      */
-    getPluginByPackageName(packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getRawPluginByPackageName(packageName);
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getPluginByPackageName(packageName) {
+        const rawResult = await this.getRawPluginByPackageName(packageName);
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
@@ -402,15 +351,13 @@ export class SchemaRepository {
      * @returns Promise that resolves to the plugin
      * @throws Error if the plugin is not found
      */
-    getRawPluginByPackageName(packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.loadPlugins();
-            const plugin = this.pluginsByPackageName.get(packageName);
-            if (!plugin) {
-                throw new Error(`Plugin with package name '${packageName}' not found`);
-            }
-            return plugin;
-        });
+    async getRawPluginByPackageName(packageName) {
+        await this.loadPlugins();
+        const plugin = this.pluginsByPackageName.get(packageName);
+        if (!plugin) {
+            throw new Error(`Plugin with package name '${packageName}' not found`);
+        }
+        return plugin;
     }
     /**
      * Prefetches all models and their fields in a single optimized API call.
@@ -423,43 +370,41 @@ export class SchemaRepository {
      *
      * @returns Promise that resolves when all data has been fetched and cached
      */
-    prefetchAllModelsAndFields() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.prefetchPromise) {
-                return this.prefetchPromise;
+    async prefetchAllModelsAndFields() {
+        if (this.prefetchPromise) {
+            return this.prefetchPromise;
+        }
+        const prefetch = async () => {
+            const { included } = await this.client.site.rawFind({
+                include: 'item_types,item_types.fields',
+            });
+            if (!included) {
+                return;
             }
-            const prefetch = () => __awaiter(this, void 0, void 0, function* () {
-                const { included } = yield this.client.site.rawFind({
-                    include: 'item_types,item_types.fields',
-                });
-                if (!included) {
-                    return;
-                }
-                const allItemTypes = included.filter((item) => item.type === 'item_type');
-                const allFields = included.filter((item) => 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();
-                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);
+            const allItemTypes = included.filter((item) => item.type === 'item_type');
+            const allFields = included.filter((item) => 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();
+            for (const field of allFields) {
+                const itemTypeId = field.relationships.item_type.data.id;
+                if (!fieldsByItemTypeId.has(itemTypeId)) {
+                    fieldsByItemTypeId.set(itemTypeId, []);
                 }
-            });
-            this.prefetchPromise = prefetch();
-            return this.prefetchPromise;
-        });
+                fieldsByItemTypeId.get(itemTypeId).push(field);
+            }
+            // Populate the fields cache
+            for (const [itemTypeId, fields] of fieldsByItemTypeId) {
+                this.fieldsByItemType.set(itemTypeId, fields);
+            }
+        };
+        this.prefetchPromise = prefetch();
+        return this.prefetchPromise;
     }
     /**
      * Gets all models that directly or indirectly embed the given block models.
@@ -470,43 +415,41 @@ export class SchemaRepository {
      * @param blocks - Array of block models to find references to
      * @returns Promise that resolves to array of models that embed these blocks
      */
-    getRawModelsEmbeddingBlocks(blocks) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.prefetchAllModelsAndFields();
-            const allItemTypes = yield this.getAllRawItemTypes();
-            const blockIds = new Set(blocks.map((block) => block.id));
-            const embeddingModels = [];
-            // Helper function to check if a model points to any of the target blocks
-            const modelPointsToBlocks = (itemType, alreadyExplored = new Set()) => __awaiter(this, void 0, void 0, function* () {
-                if (alreadyExplored.has(itemType.id)) {
-                    return false;
+    async getRawModelsEmbeddingBlocks(blocks) {
+        await this.prefetchAllModelsAndFields();
+        const allItemTypes = await this.getAllRawItemTypes();
+        const blockIds = new Set(blocks.map((block) => block.id));
+        const embeddingModels = [];
+        // Helper function to check if a model points to any of the target blocks
+        const modelPointsToBlocks = async (itemType, alreadyExplored = new Set()) => {
+            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;
                 }
-                alreadyExplored.add(itemType.id);
-                const fields = yield 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))) {
+                // 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;
                     }
-                    // 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 (yield 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 (yield modelPointsToBlocks(itemType)) {
-                    embeddingModels.push(itemType);
                 }
             }
-            return embeddingModels;
-        });
+            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.
@@ -517,12 +460,10 @@ export class SchemaRepository {
      * @param blocks - Array of block models to find references to
      * @returns Promise that resolves to array of models that embed these blocks
      */
-    getModelsEmbeddingBlocks(blocks) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getRawModelsEmbeddingBlocks(blocks);
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getModelsEmbeddingBlocks(blocks) {
+        const rawResult = await this.getRawModelsEmbeddingBlocks(blocks);
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
@@ -534,40 +475,38 @@ export class SchemaRepository {
      * @param itemTypes - Array of item types to find nested blocks for
      * @returns Promise that resolves to array of all block models nested in these item types
      */
-    getRawNestedBlocks(itemTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.prefetchAllModelsAndFields();
-            const allItemTypes = yield this.getAllRawItemTypes();
-            const visited = new Set();
-            const nestedBlocks = [];
-            // Helper function to recursively find nested blocks
-            const findNestedBlocks = (itemType, alreadyExplored = new Set()) => __awaiter(this, void 0, void 0, function* () {
-                if (alreadyExplored.has(itemType.id)) {
-                    return;
-                }
-                alreadyExplored.add(itemType.id);
-                const fields = yield this.getRawItemTypeFields(itemType);
-                for (const field of fields) {
-                    const referencedBlockIds = blockModelIdsReferencedInField(field);
-                    for (const blockId of referencedBlockIds) {
-                        if (!visited.has(blockId)) {
-                            visited.add(blockId);
-                            const nestedBlock = allItemTypes.find((it) => it.id === blockId);
-                            if (nestedBlock) {
-                                nestedBlocks.push(nestedBlock);
-                                // Recursively find blocks nested in this block
-                                yield findNestedBlocks(nestedBlock, new Set(alreadyExplored));
-                            }
+    async getRawNestedBlocks(itemTypes) {
+        await this.prefetchAllModelsAndFields();
+        const allItemTypes = await this.getAllRawItemTypes();
+        const visited = new Set();
+        const nestedBlocks = [];
+        // Helper function to recursively find nested blocks
+        const findNestedBlocks = async (itemType, alreadyExplored = new Set()) => {
+            if (alreadyExplored.has(itemType.id)) {
+                return;
+            }
+            alreadyExplored.add(itemType.id);
+            const fields = await this.getRawItemTypeFields(itemType);
+            for (const field of fields) {
+                const referencedBlockIds = blockModelIdsReferencedInField(field);
+                for (const blockId of referencedBlockIds) {
+                    if (!visited.has(blockId)) {
+                        visited.add(blockId);
+                        const nestedBlock = allItemTypes.find((it) => it.id === blockId);
+                        if (nestedBlock) {
+                            nestedBlocks.push(nestedBlock);
+                            // Recursively find blocks nested in this block
+                            await findNestedBlocks(nestedBlock, new Set(alreadyExplored));
                         }
                     }
                 }
-            });
-            // Find nested blocks for each provided item type
-            for (const itemType of itemTypes) {
-                yield findNestedBlocks(itemType);
             }
-            return nestedBlocks;
-        });
+        };
+        // Find nested blocks for each provided item type
+        for (const itemType of itemTypes) {
+            await findNestedBlocks(itemType);
+        }
+        return nestedBlocks;
     }
     /**
      * Gets all block models that are directly or indirectly nested within the given item types.
@@ -578,12 +517,10 @@ export class SchemaRepository {
      * @param itemTypes - Array of item types to find nested blocks for
      * @returns Promise that resolves to array of all block models nested in these item types
      */
-    getNestedBlocks(itemTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getRawNestedBlocks(itemTypes);
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getNestedBlocks(itemTypes) {
+        const rawResult = await this.getRawNestedBlocks(itemTypes);
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
     /**
@@ -595,49 +532,47 @@ export class SchemaRepository {
      * @param itemTypes - Array of item types to find nested models for
      * @returns Promise that resolves to array of all models nested in these item types
      */
-    getRawNestedModels(itemTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.prefetchAllModelsAndFields();
-            const allItemTypes = yield this.getAllRawItemTypes();
-            const visited = new Set();
-            const nestedModels = [];
-            // Helper function to recursively find nested models
-            const findNestedModels = (itemType, alreadyExplored = new Set()) => __awaiter(this, void 0, void 0, function* () {
-                if (alreadyExplored.has(itemType.id)) {
-                    return;
-                }
-                alreadyExplored.add(itemType.id);
-                const fields = yield this.getRawItemTypeFields(itemType);
-                for (const field of fields) {
-                    // Find models directly referenced via link fields
-                    const referencedModelIds = modelIdsReferencedInField(field);
-                    for (const modelId of referencedModelIds) {
-                        if (!visited.has(modelId)) {
-                            visited.add(modelId);
-                            const nestedModel = allItemTypes.find((it) => it.id === modelId);
-                            if (nestedModel) {
-                                nestedModels.push(nestedModel);
-                                // Do NOT recurse into models, only into blocks
-                            }
+    async getRawNestedModels(itemTypes) {
+        await this.prefetchAllModelsAndFields();
+        const allItemTypes = await this.getAllRawItemTypes();
+        const visited = new Set();
+        const nestedModels = [];
+        // Helper function to recursively find nested models
+        const findNestedModels = async (itemType, alreadyExplored = new Set()) => {
+            if (alreadyExplored.has(itemType.id)) {
+                return;
+            }
+            alreadyExplored.add(itemType.id);
+            const fields = await this.getRawItemTypeFields(itemType);
+            for (const field of fields) {
+                // Find models directly referenced via link fields
+                const referencedModelIds = modelIdsReferencedInField(field);
+                for (const modelId of referencedModelIds) {
+                    if (!visited.has(modelId)) {
+                        visited.add(modelId);
+                        const nestedModel = allItemTypes.find((it) => it.id === modelId);
+                        if (nestedModel) {
+                            nestedModels.push(nestedModel);
+                            // Do NOT recurse into models, only into blocks
                         }
                     }
-                    // Find blocks referenced via block fields, then recursively find models in those blocks
-                    const referencedBlockIds = blockModelIdsReferencedInField(field);
-                    for (const blockId of referencedBlockIds) {
-                        const nestedBlock = allItemTypes.find((it) => it.id === blockId);
-                        if (nestedBlock) {
-                            // Recursively find models nested in this block
-                            yield findNestedModels(nestedBlock, new Set(alreadyExplored));
-                        }
+                }
+                // Find blocks referenced via block fields, then recursively find models in those blocks
+                const referencedBlockIds = blockModelIdsReferencedInField(field);
+                for (const blockId of referencedBlockIds) {
+                    const nestedBlock = allItemTypes.find((it) => it.id === blockId);
+                    if (nestedBlock) {
+                        // Recursively find models nested in this block
+                        await findNestedModels(nestedBlock, new Set(alreadyExplored));
                     }
                 }
-            });
-            // Find nested models for each provided item type
-            for (const itemType of itemTypes) {
-                yield findNestedModels(itemType);
             }
-            return nestedModels;
-        });
+        };
+        // Find nested models for each provided item type
+        for (const itemType of itemTypes) {
+            await findNestedModels(itemType);
+        }
+        return nestedModels;
     }
     /**
      * Gets all models that are directly or indirectly nested/referenced within the given item types.
@@ -648,12 +583,10 @@ export class SchemaRepository {
      * @param itemTypes - Array of item types to find nested models for
      * @returns Promise that resolves to array of all models nested in these item types
      */
-    getNestedModels(itemTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawResult = yield this.getRawNestedModels(itemTypes);
-            return deserializeResponseBody({
-                data: rawResult,
-            });
+    async getNestedModels(itemTypes) {
+        const rawResult = await this.getRawNestedModels(itemTypes);
+        return deserializeResponseBody({
+            data: rawResult,
         });
     }
 }