@vertexvis/api-client-node 0.20.10 → 0.21.1

package/dist/esm/client/helpers/scene-items.d.ts

@@ -1,5 +1,24 @@
 import { CreateSceneItemRequest, SceneItem } from '../../index';
 import { BaseReq, Polling } from '../index';
+export declare enum SceneItemErrorStatus {
+    NotFound = "404",
+    ServerError = "500"
+}
+export declare enum SceneItemErrorCode {
+    NotFound = "NotFound",
+    ServerError = "ServerError"
+}
+export declare enum SceneItemErrorSourcePointer {
+    Parent = "/body/data/attributes/parent",
+    SourcePart = "/body/data/relationships/source/data"
+}
+export declare enum SceneItemSystemMetadata {
+    IsMissingGeometry = "VERTEX_IS_MISSING_GEOMETRY",
+    MissingGeometrySetId = "VERTEX_MISSING_GEOMETRY_SET_ID",
+    MissingPartRevisionId = "VERTEX_MISSING_PART_REVISION_ID",
+    MissingSuppliedPartId = "VERTEX_MISSING_SUPPLIED_PART_ID",
+    MissingSuppliedPartRevisionId = "VERTEX_MISSING_SUPPLIED_PART_REVISION_ID"
+}
 /**
  * Create scene item arguments.
  */
@@ -17,3 +36,5 @@ export interface CreateSceneItemReq extends BaseReq {
  * @param args - The {@link CreateSceneItemReq}.
  */
 export declare function createSceneItem({ client, createSceneItemReq, onMsg, polling, sceneId, verbose, }: CreateSceneItemReq): Promise<SceneItem>;
+export declare function isPartNotFoundError(e: unknown): boolean;
+export declare function isParentNotFoundError(e: unknown): boolean;

package/dist/esm/client/helpers/scene-items.js

@@ -7,7 +7,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { isPollError, MaxAttempts, PollIntervalMs, pollQueuedJob, throwOnError, } from '../index';
+import { defined, isApiError, isPollError, MaxAttempts, PollIntervalMs, pollQueuedJob, throwOnError, } from '../index';
+export var SceneItemErrorStatus;
+(function (SceneItemErrorStatus) {
+    SceneItemErrorStatus["NotFound"] = "404";
+    SceneItemErrorStatus["ServerError"] = "500";
+})(SceneItemErrorStatus || (SceneItemErrorStatus = {}));
+export var SceneItemErrorCode;
+(function (SceneItemErrorCode) {
+    SceneItemErrorCode["NotFound"] = "NotFound";
+    SceneItemErrorCode["ServerError"] = "ServerError";
+})(SceneItemErrorCode || (SceneItemErrorCode = {}));
+export var SceneItemErrorSourcePointer;
+(function (SceneItemErrorSourcePointer) {
+    SceneItemErrorSourcePointer["Parent"] = "/body/data/attributes/parent";
+    SceneItemErrorSourcePointer["SourcePart"] = "/body/data/relationships/source/data";
+})(SceneItemErrorSourcePointer || (SceneItemErrorSourcePointer = {}));
+export var SceneItemSystemMetadata;
+(function (SceneItemSystemMetadata) {
+    SceneItemSystemMetadata["IsMissingGeometry"] = "VERTEX_IS_MISSING_GEOMETRY";
+    SceneItemSystemMetadata["MissingGeometrySetId"] = "VERTEX_MISSING_GEOMETRY_SET_ID";
+    SceneItemSystemMetadata["MissingPartRevisionId"] = "VERTEX_MISSING_PART_REVISION_ID";
+    SceneItemSystemMetadata["MissingSuppliedPartId"] = "VERTEX_MISSING_SUPPLIED_PART_ID";
+    SceneItemSystemMetadata["MissingSuppliedPartRevisionId"] = "VERTEX_MISSING_SUPPLIED_PART_REVISION_ID";
+})(SceneItemSystemMetadata || (SceneItemSystemMetadata = {}));
 /**
  * Create a scene item.
  *
@@ -34,3 +57,17 @@ export function createSceneItem({ client, createSceneItemReq, onMsg = console.lo
         return pollRes.res;
     });
 }
+export function isPartNotFoundError(e) {
+    return (defined(e) &&
+        isApiError(e) &&
+        e.code === SceneItemErrorCode.NotFound &&
+        e.source !== undefined &&
+        e.source.pointer === SceneItemErrorSourcePointer.SourcePart);
+}
+export function isParentNotFoundError(e) {
+    return (defined(e) &&
+        isApiError(e) &&
+        e.code === SceneItemErrorCode.NotFound &&
+        e.source !== undefined &&
+        e.source.pointer === SceneItemErrorSourcePointer.Parent);
+}

package/dist/esm/client/helpers/scenes.d.ts

@@ -1,4 +1,6 @@
 import { AxiosResponse } from 'axios';
+import { Limit } from 'p-limit';
+import { RelationshipData } from '../../index';
 import { ApiError, BatchOperation, CreateSceneItemRequest, CreateSceneItemRequestData, CreateSceneRequest, Failure, QueuedJob, Scene, SceneData, UpdateSceneRequestDataAttributes } from '../../index';
 import { BaseReq, DeleteReq, Polling, RenderImageReq, VertexClient } from '../index';
 export interface CreateSceneAndSceneItemsReq extends BaseReq {
@@ -17,35 +19,23 @@ export interface CreateSceneAndSceneItemsReq extends BaseReq {
     /** Whether or not to return queued scene items. */
     readonly returnQueued?: boolean;
 }
-export interface CreateSceneAndSceneItemsReqEXPERIMENTAL extends BaseReq {
-    /** A list of {@link CreateSceneItemRequest}. */
-    readonly createSceneItemReqs: Array<Array<CreateSceneItemRequest>>;
-    /** Function returning a {@link CreateSceneRequest}. */
-    readonly createSceneReq: () => CreateSceneRequest;
-    /** Whether or not to fail if any scene item fails initial validation. */
-    readonly failFast?: boolean;
-    /** How many requests to run in parallel. */
-    readonly parallelism: number;
-    /** {@link Polling} */
-    readonly polling?: Polling;
-    /** Callback with total number of requests and number complete. */
-    onProgress?: (complete: number, total: number) => void;
-    /** Whether or not to return queued scene items. */
-    readonly returnQueued?: boolean;
-}
 export interface CreateSceneAndSceneItemsRes {
-    readonly errors: QueuedSceneItem[];
-    readonly scene: Scene;
-    /** Only populated if `returnQueued` is true in request. */
-    readonly queued: QueuedSceneItem[];
-}
-export interface CreateSceneAndSceneItemsResEXPERIMENTAL {
     readonly errors: QueuedBatchOps[];
-    readonly scene: Scene;
+    readonly scene?: Scene;
     readonly sceneItemErrors: SceneItemError[];
     /** Only populated if `returnQueued` is true in request. */
     readonly queued: QueuedBatchOps[];
 }
+export interface CreateSceneItemBatchReq extends CreateSceneItemsReq {
+    /** {@link Polling} */
+    readonly polling?: Polling;
+}
+export interface CreateSceneItemBatchRes {
+    batchOps: QueuedBatchOps[];
+    batchErrors: QueuedBatchOps[];
+    itemErrors: SceneItemError[];
+    itemResults: SceneItemResult[];
+}
 export interface CreateSceneItemsReq extends Base {
     /** A list of {@link CreateSceneItemRequest}. */
     readonly createSceneItemReqs: CreateSceneItemRequest[];
@@ -53,14 +43,10 @@ export interface CreateSceneItemsReq extends Base {
     readonly failFast: boolean;
     /** Callback with total number of requests and number complete. */
     readonly onProgress?: (complete: number, total: number) => void;
-    /** How many requests to run in parallel. */
-    readonly parallelism: number;
+    /** Limit for requests to run in parallel. */
+    readonly limit: Limit;
 }
 export interface CreateSceneItemsRes {
-    readonly leaves: number;
-    readonly queuedSceneItems: QueuedSceneItem[];
-}
-export interface CreateSceneItemsResEXPERIMENTAL {
     readonly chunks: number;
     readonly queuedBatchOps: QueuedBatchOps[];
 }
@@ -71,6 +57,11 @@ export interface QueuedBatchOps {
 export interface SceneItemError {
     readonly req: CreateSceneItemRequestData;
     readonly res?: ApiError;
+    placeholderItem?: RelationshipData;
+}
+export interface SceneItemResult {
+    readonly req: CreateSceneItemRequestData;
+    readonly res: RelationshipData | ApiError;
 }
 /**
  * Poll scene ready arguments.
@@ -104,15 +95,7 @@ export declare function createSceneAndSceneItems({ client, createSceneItemReqs,
 /**
  * Create scene items within a scene.
  */
-export declare function createSceneItems({ client, createSceneItemReqs, failFast, onProgress, parallelism, sceneId, }: CreateSceneItemsReq): Promise<CreateSceneItemsRes>;
-/**
- * Create a scene with scene items using experimental strategy.
- */
-export declare function createSceneAndSceneItemsEXPERIMENTAL({ client, createSceneItemReqs, createSceneReq, failFast, onMsg, onProgress, parallelism, polling, returnQueued, verbose, }: CreateSceneAndSceneItemsReqEXPERIMENTAL): Promise<CreateSceneAndSceneItemsResEXPERIMENTAL>;
-/**
- * Create scene items within a scene.
- */
-export declare function createSceneItemsEXPERIMENTAL({ client, createSceneItemReqs, failFast, parallelism, sceneId, }: CreateSceneItemsReq): Promise<CreateSceneItemsResEXPERIMENTAL>;
+export declare function createSceneItems({ client, createSceneItemReqs, failFast, limit, sceneId, }: CreateSceneItemsReq): Promise<CreateSceneItemsRes>;
 /**
  * Delete all scenes.
  *

package/dist/esm/client/helpers/scenes.js

@@ -10,239 +10,280 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import pLimit from 'p-limit';
 import { hrtime } from 'process';
 import { BatchOperationOpEnum, BatchOperationRefTypeEnum, CameraFitTypeEnum, SceneRelationshipDataTypeEnum, UpdateSceneRequestDataAttributesStateEnum, } from '../../index';
-import { defined, getPage, hasVertexError, isQueuedJob, MaxAttempts, partition, PollIntervalMs, tryStream, } from '../index';
-import { arrayChunked, delay, isApiError, toAccept } from '../utils';
+import { defined, getPage, hasVertexError, isPartNotFoundError, isQueuedJob, MaxAttempts, partition, PollIntervalMs, SceneItemSystemMetadata, tryStream, } from '../index';
+import { arrayChunked, delay, formatTime, isApiError, isSceneItemRelationship, toAccept, } from '../utils';
 import { isBatch, isPollError, pollQueuedJob, throwOnError, } from './queued-jobs';
-const PollPercentage = 10;
+const defaultPolling = { intervalMs: 200, maxAttempts: 4500 }; // 15 minute timeout for batch completions
+const sceneReadyPolling = { intervalMs: 1000, maxAttempts: 3600 }; // one hour timeout for scene state ready
 /**
  * Create a scene with scene items.
  */
-export function createSceneAndSceneItems({ client, createSceneItemReqs, createSceneReq, failFast = false, onMsg = console.log, onProgress, parallelism, polling = { intervalMs: PollIntervalMs, maxAttempts: MaxAttempts }, returnQueued = false, verbose, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const scene = (yield client.scenes.createScene({ createSceneRequest: createSceneReq() })).data;
-        const sceneId = scene.data.id;
-        const createRes = yield createSceneItems({
-            client,
-            createSceneItemReqs,
-            failFast,
-            onProgress,
-            parallelism,
-            sceneId,
-        });
-        const { a: queuedItems, b: errors } = partition(createRes.queuedSceneItems, (i) => isQueuedJob(i.res));
-        const queued = returnQueued ? createRes.queuedSceneItems : [];
-        if (queuedItems.length === 0 || errors.length === createRes.leaves) {
-            return { errors, queued, scene };
-        }
-        if (verbose)
-            onMsg(`Polling for completed scene-items...`);
-        const limit = pLimit(Math.min(parallelism, 20));
-        const cnt = queuedItems.length;
-        const step = Math.floor(cnt / ((PollPercentage / 100) * cnt));
-        const qis = [];
-        // Poll for percentage of items starting at end of `queuedItems` array
-        for (let i = 0; i < cnt; i += step)
-            qis.push(queuedItems[cnt - i - 1]);
-        function poll({ req, res }) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const r = yield pollQueuedJob({
-                    id: res.data.id,
-                    getQueuedJob: (id, cancelToken) => client.sceneItems.getQueuedSceneItem({ id }, { cancelToken }),
-                    allow404: true,
-                    limit,
-                    polling,
-                });
-                if (isPollError(r.res)) {
-                    failFast ? throwOnError(r) : errors.push({ req, res: r.res });
-                }
-            });
-        }
-        yield Promise.all(qis.map((is) => limit(poll, is)));
-        if (verbose)
-            onMsg(`Committing scene and polling until ready...`);
-        yield updateScene({
-            attributes: { state: UpdateSceneRequestDataAttributesStateEnum.Commit },
-            client,
-            sceneId,
-        });
-        yield pollSceneReady({ client, id: sceneId, onMsg, polling, verbose });
-        if (verbose)
-            onMsg(`Fitting scene's camera to scene-items...`);
-        const updated = (yield updateScene({
-            attributes: { camera: { type: CameraFitTypeEnum.FitVisibleSceneItems } },
-            client,
-            sceneId,
-        })).scene;
-        return { errors, queued, scene: updated };
-    });
-}
-/**
- * Create scene items within a scene.
- */
-export function createSceneItems({ client, createSceneItemReqs, failFast, onProgress, parallelism, sceneId, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const limit = pLimit(parallelism);
-        let complete = 0;
-        let leaves = 0;
-        const queuedSceneItems = yield Promise.all(createSceneItemReqs.map((r) => limit((req) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            let res;
-            try {
-                if (defined(req.data.attributes.source) ||
-                    defined(req.data.relationships.source)) {
-                    leaves++;
-                }
-                res = (yield client.sceneItems.createSceneItem({
-                    id: sceneId,
-                    createSceneItemRequest: req,
-                })).data;
-            }
-            catch (error) {
-                if (!failFast && hasVertexError(error)) {
-                    res = (_a = error.vertexError) === null || _a === void 0 ? void 0 : _a.res;
-                }
-                else
-                    throw error;
-            }
-            if (onProgress != null) {
-                complete += 1;
-                onProgress(complete, createSceneItemReqs.length);
-            }
-            return { req, res };
-        }), r)));
-        return { leaves, queuedSceneItems };
-    });
-}
-/**
- * Create a scene with scene items using experimental strategy.
- */
-export function createSceneAndSceneItemsEXPERIMENTAL({ client, createSceneItemReqs, createSceneReq, failFast = false, onMsg = console.log, onProgress, parallelism, polling = { intervalMs: PollIntervalMs, maxAttempts: MaxAttempts }, returnQueued = false, verbose, }) {
+export function createSceneAndSceneItems({ client, createSceneItemReqs, createSceneReq, failFast = false, onMsg = console.log, onProgress, parallelism, polling = defaultPolling, returnQueued = false, verbose, }) {
     return __awaiter(this, void 0, void 0, function* () {
+        const limit = pLimit(Math.min(parallelism, 100));
         const startTime = hrtime.bigint();
         if (verbose)
             onMsg(`Creating scene...`);
         const scene = (yield client.scenes.createScene({ createSceneRequest: createSceneReq() })).data;
         const sceneId = scene.data.id;
+        if (verbose)
+            onMsg(`Scene ID: ${sceneId}`);
         if (verbose)
             onMsg(`Creating scene items...`);
         let itemCount = 0;
-        let batchQueuedOps = [];
-        let batchErrors = [];
-        let sceneItemErrors = [];
-        for (let depth = 0; depth < createSceneItemReqs.length; depth++) {
-            const createItemReqs = createSceneItemReqs[depth];
+        let createFailed = false;
+        let sceneResult;
+        const reqMap = new Map();
+        // create parent map and set ordinals based on request order
+        createSceneItemReqs.forEach((req) => {
+            var _a, _b, _c;
+            const reqParent = (_c = (_a = req.data.attributes.parent) !== null && _a !== void 0 ? _a : (_b = req.data.relationships.parent) === null || _b === void 0 ? void 0 : _b.data.id) !== null && _c !== void 0 ? _c : '';
+            if (!reqMap.has(reqParent)) {
+                reqMap.set(reqParent, []);
+            }
+            const siblings = reqMap.get(reqParent);
+            if (req.data.attributes.ordinal == null) {
+                req.data.attributes.ordinal = siblings === null || siblings === void 0 ? void 0 : siblings.length;
+            }
+            siblings === null || siblings === void 0 ? void 0 : siblings.push(req);
+        });
+        // sort all scene item requests into depth sorted array of arrays
+        const depthSortedItems = [];
+        // fetch list of scene items with no parent (root items)
+        let nextChildren = reqMap.get('') || [];
+        reqMap.delete('');
+        while (nextChildren.length > 0) {
+            depthSortedItems.push(nextChildren);
+            nextChildren = nextChildren.flatMap((req) => {
+                if (req.data.attributes.suppliedId &&
+                    reqMap.has(req.data.attributes.suppliedId)) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const children = reqMap.get(req.data.attributes.suppliedId);
+                    reqMap.delete(req.data.attributes.suppliedId);
+                    return children;
+                }
+                else {
+                    return [];
+                }
+            });
+        }
+        let resultQueuedOps = [];
+        let resultBatchErrors = [];
+        let resultItemErrors = [];
+        // if we had any scene item requests with invalid parents,
+        // add error entries indicating so.
+        reqMap.forEach((children) => {
+            children.forEach((childItem) => {
+                resultItemErrors.push({
+                    req: childItem.data,
+                    res: {
+                        status: '404',
+                        code: 'NotFound',
+                        title: 'The requested resource was not found.',
+                        source: { pointer: '/body/data/attributes/parent' },
+                    },
+                });
+            });
+        });
+        let depth = 0;
+        for (depth; depth < depthSortedItems.length; depth++) {
+            const createItemReqs = depthSortedItems[depth];
             itemCount += createItemReqs.length;
             if (verbose)
                 onMsg(`Creating ${createItemReqs.length} scene items at depth ${depth}...`);
             // Await is used intentionally to defer loop iteration
             // until all scene items have been created at each depth.
+            const { batchOps: queuedBatchOps, batchErrors: queuedBatchErrors, itemErrors: batchItemErrors, } = 
             // eslint-disable-next-line no-await-in-loop
-            const createRes = yield createSceneItemsEXPERIMENTAL({
+            yield createSceneItemBatch({
                 client,
                 createSceneItemReqs: createItemReqs,
                 failFast,
                 onProgress,
-                parallelism,
+                limit,
                 sceneId,
+                polling,
             });
-            const { a: queuedOps, b: errors } = partition(createRes.queuedBatchOps, (i) => isQueuedJob(i.res));
-            batchQueuedOps = batchQueuedOps.concat(queuedOps);
-            if (errors.length) {
-                batchErrors = batchErrors.concat(errors);
-                if (verbose)
-                    onMsg(`WARNING: ${errors.length} scene item batch errors at depth ${depth}.`);
-            }
-            // Nothing succeeded, return early as something is likely wrong
-            if (queuedOps.length === 0 || errors.length === createRes.chunks) {
-                return {
-                    errors,
-                    queued: returnQueued ? createRes.queuedBatchOps : [],
-                    scene,
-                    sceneItemErrors: [],
-                };
-            }
-            const limit = pLimit(Math.min(parallelism, 20));
-            function poll({ ops, res, }) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const r = yield pollQueuedJob({
-                        id: res.data.id,
-                        getQueuedJob: (id, cancelToken) => client.batches.getQueuedBatch({ id }, { cancelToken }),
-                        allow404: true,
-                        limit,
-                        polling,
-                    });
-                    if (isPollError(r.res)) {
-                        failFast ? throwOnError(r) : errors.push({ ops, res: r.res });
-                    }
-                    return r;
-                });
-            }
-            // eslint-disable-next-line no-await-in-loop
-            const batchRes = yield Promise.all(queuedOps.map((is) => limit(poll, is)));
-            const batchItemErrors = batchRes
-                .flatMap((b, i) => isBatch(b.res)
-                ? b.res['vertexvis/batch:results'].map((r, j) => isApiError(r)
-                    ? { req: queuedOps[i].ops[j].data, res: r }
-                    : undefined)
-                : [])
-                .filter(defined);
+            resultQueuedOps = resultQueuedOps.concat(queuedBatchOps);
+            resultBatchErrors = resultBatchErrors.concat(queuedBatchErrors);
             if (batchItemErrors.length) {
-                sceneItemErrors = sceneItemErrors.concat(batchItemErrors);
                 if (verbose)
                     onMsg(`WARNING: ${batchItemErrors.length} scene item creation errors at depth ${depth}.`);
+                resultItemErrors = resultItemErrors.concat(batchItemErrors);
+                if (failFast) {
+                    createFailed = true;
+                    break;
+                }
+                else {
+                    // evaluate item errors and generate retry list
+                    const retryErrors = batchItemErrors.filter((v) => isPartNotFoundError(v.res));
+                    const retries = retryErrors.map((itemError) => {
+                        var _a, _b, _c, _d, _e, _f;
+                        const item = itemError.req;
+                        return {
+                            data: {
+                                type: 'scene-item',
+                                attributes: Object.assign(Object.assign({}, item.attributes), { metadata: Object.assign(Object.assign({}, item.attributes.metadata), { [SceneItemSystemMetadata.IsMissingGeometry]: toMetadataOrUndefined('1'), [SceneItemSystemMetadata.MissingGeometrySetId]: toMetadataOrUndefined((_a = item.relationships.source) === null || _a === void 0 ? void 0 : _a.data.id, ((_b = item.relationships.source) === null || _b === void 0 ? void 0 : _b.data.type) === 'geometry-set'), [SceneItemSystemMetadata.MissingPartRevisionId]: toMetadataOrUndefined((_c = item.relationships.source) === null || _c === void 0 ? void 0 : _c.data.id, ((_d = item.relationships.source) === null || _d === void 0 ? void 0 : _d.data.type) === 'part-revision'), [SceneItemSystemMetadata.MissingSuppliedPartId]: toMetadataOrUndefined((_e = item.attributes.source) === null || _e === void 0 ? void 0 : _e.suppliedPartId), [SceneItemSystemMetadata.MissingSuppliedPartRevisionId]: toMetadataOrUndefined((_f = item.attributes.source) === null || _f === void 0 ? void 0 : _f.suppliedRevisionId) }), source: undefined }),
+                                relationships: Object.assign(Object.assign({}, item.relationships), { source: undefined }),
+                            },
+                        };
+                    });
+                    if (retries.length > 0) {
+                        onMsg(`Creating ${retries.length} placeholder scene items at depth ${depth}.`);
+                        // wait for placeholders to be created
+                        const { itemResults: placeholderItemResults } = 
+                        // eslint-disable-next-line no-await-in-loop
+                        yield createSceneItemBatch({
+                            client,
+                            createSceneItemReqs: retries,
+                            failFast,
+                            onProgress,
+                            limit,
+                            sceneId,
+                            polling,
+                        });
+                        // attach placeholder references to item errors
+                        placeholderItemResults.forEach((resultItem, i) => {
+                            if (isSceneItemRelationship(resultItem.res)) {
+                                retryErrors[i].placeholderItem = resultItem.res;
+                            }
+                        });
+                    }
+                }
             }
         }
-        if (verbose) {
-            onMsg(`Scene item creation complete for ${itemCount} scene items with max depth of ${createSceneItemReqs.length - 1}.`);
-            if (batchErrors.length) {
-                onMsg(`  Batch errors: ${batchErrors.length}`);
+        if (createFailed) {
+            if (verbose) {
+                onMsg(`Scene item creation failed in ${formatTime(Number(hrtime.bigint() - startTime) / 1000000000)} at depth ${depth}.`);
             }
-            if (sceneItemErrors.length) {
-                onMsg(`  Scene item errors: ${sceneItemErrors.length}`);
+        }
+        else {
+            if (verbose) {
+                onMsg(`Scene item creation completed in ${formatTime(Number(hrtime.bigint() - startTime) / 1000000000)} for ${itemCount} scene items with max depth of ${depthSortedItems.length - 1}.`);
+                if (resultBatchErrors.length) {
+                    onMsg(`Batch errors: ${resultBatchErrors.length}`);
+                }
+                if (resultItemErrors.length) {
+                    onMsg(`Scene item errors: ${resultItemErrors.length}`);
+                }
             }
+            if (verbose)
+                onMsg(`Committing scene and polling until ready...`);
+            yield updateScene({
+                attributes: { state: UpdateSceneRequestDataAttributesStateEnum.Commit },
+                client,
+                sceneId,
+            });
+            yield pollSceneReady({
+                client,
+                id: sceneId,
+                onMsg,
+                polling: sceneReadyPolling,
+                verbose,
+            });
+            if (verbose)
+                onMsg(`Fitting scene's camera to scene items...`);
+            sceneResult = (yield updateScene({
+                attributes: {
+                    camera: { type: CameraFitTypeEnum.FitVisibleSceneItems },
+                },
+                client,
+                sceneId,
+            })).scene;
         }
-        if (verbose)
-            onMsg(`Committing scene and polling until ready...`);
-        yield updateScene({
-            attributes: { state: UpdateSceneRequestDataAttributesStateEnum.Commit },
-            client,
-            sceneId,
-        });
-        yield pollSceneReady({ client, id: sceneId, onMsg, polling, verbose });
-        if (verbose)
-            onMsg(`Fitting scene's camera to scene items...`);
-        const sceneResult = (yield updateScene({
-            attributes: {
-                camera: { type: CameraFitTypeEnum.FitVisibleSceneItems },
-            },
-            client,
-            sceneId,
-        })).scene;
         if (verbose) {
-            const formatTime = (seconds) => {
-                const h = Math.floor(seconds / 3600);
-                const m = Math.floor((seconds % 3600) / 60);
-                const s = Math.round(seconds % 60);
-                return [h, m > 9 ? m : h ? '0' + m : m || '0', s > 9 ? s : '0' + s]
-                    .filter(Boolean)
-                    .join(':');
-            };
             onMsg(`Scene creation completed in ${formatTime(Number(hrtime.bigint() - startTime) / 1000000000)}.`);
         }
         return {
-            errors: batchErrors,
-            queued: batchQueuedOps,
+            errors: resultBatchErrors,
+            queued: returnQueued ? resultQueuedOps : [],
             scene: sceneResult,
-            sceneItemErrors,
+            sceneItemErrors: resultItemErrors,
         };
     });
 }
+/**
+ * Helper function for building a metadata string object.
+ *
+ * @param value Value to convert to metadata object
+ * @param condition Setting to `false` will cause result to be `undefined`
+ * @returns Instance of a `MetadataValue` object
+ */
+function toMetadataOrUndefined(value, condition = true) {
+    return condition && defined(value)
+        ? {
+            type: 'string',
+            value,
+        }
+        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            undefined;
+}
+/**
+ * This async function takes a long list of create scene item data and handles
+ * batch based scene item creation. Batch operation results and errors are
+ * returned to the caller.
+ */
+const createSceneItemBatch = ({ client, createSceneItemReqs: createItemReqs, failFast, onProgress, limit, sceneId, polling = { intervalMs: PollIntervalMs, maxAttempts: MaxAttempts }, }) => __awaiter(void 0, void 0, void 0, function* () {
+    let batchErrors = [];
+    let itemErrors = [];
+    let itemResults = [];
+    const createRes = yield createSceneItems({
+        client,
+        createSceneItemReqs: createItemReqs,
+        failFast,
+        onProgress,
+        limit,
+        sceneId,
+    });
+    const { a: batchOps, b: errors } = partition(createRes.queuedBatchOps, (i) => isQueuedJob(i.res));
+    if (errors.length) {
+        batchErrors = batchErrors.concat(errors);
+    }
+    // Nothing succeeded, return early as something is likely wrong
+    if (batchOps.length === 0 || errors.length === createRes.chunks) {
+        return { batchOps, batchErrors, itemErrors, itemResults };
+    }
+    else {
+        function poll({ ops, res, }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const r = yield pollQueuedJob({
+                    id: res.data.id,
+                    getQueuedJob: (id, cancelToken) => client.batches.getQueuedBatch({ id }, { cancelToken }),
+                    allow404: true,
+                    limit,
+                    polling,
+                });
+                if (isPollError(r.res)) {
+                    failFast ? throwOnError(r) : errors.push({ ops, res: r.res });
+                }
+                return r;
+            });
+        }
+        // eslint-disable-next-line no-await-in-loop
+        const batchRes = yield Promise.all(batchOps.map((is) => limit(poll, is)));
+        itemResults = batchRes.flatMap((b, i) => isBatch(b.res)
+            ? b.res['vertexvis/batch:results'].map((r, j) => {
+                return { req: batchOps[i].ops[j].data, res: r };
+            })
+            : []);
+        itemErrors = itemErrors.concat(itemResults.filter((resultItem) => isApiError(resultItem.res)));
+    }
+    // if the full batch failed add batch item error for each item
+    errors.forEach((error) => {
+        console.log(error);
+        error.ops.forEach((op) => {
+            // `error.res` guaranteed to be non-null due to `isApiError()` condition above
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            itemErrors.push({ req: op.data, res: error.res });
+        });
+    });
+    return { batchOps, batchErrors, itemErrors, itemResults };
+});
 /**
  * Create scene items within a scene.
  */
-export function createSceneItemsEXPERIMENTAL({ client, createSceneItemReqs, failFast, parallelism, sceneId, }) {
+export function createSceneItems({ client, createSceneItemReqs, failFast, limit, sceneId, }) {
     return __awaiter(this, void 0, void 0, function* () {
-        const limit = pLimit(parallelism);
         const batchSize = 500;
         const opChunks = arrayChunked(createSceneItemReqs.map((req) => ({
             data: req.data,

package/dist/esm/client/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { AxiosError, AxiosResponse, Method } from 'axios';
 import { ParsedUrlQuery } from 'querystring';
-import { ApiError, Failure, ImageType, Matrix4, Oauth2Api, OAuth2Token, QueuedJob } from '../index';
+import { ApiError, Failure, ImageType, Matrix4, Oauth2Api, OAuth2Token, QueuedJob, RelationshipData } from '../index';
 export interface Cursors {
     readonly next?: string;
     readonly self?: string;
@@ -136,6 +136,7 @@ export declare function is4x4Identity(transform: number[][]): boolean;
  */
 export declare function isEncoded(s: string): boolean;
 export declare function isApiError(error: unknown): error is ApiError;
+export declare function isSceneItemRelationship(data: unknown): data is RelationshipData;
 export declare function isFailure(obj: unknown): obj is Failure;
 export declare function isQueuedJob(obj: unknown): obj is QueuedJob;
 export declare function hasVertexError(error: unknown): error is VertexError;
@@ -225,3 +226,9 @@ export declare function tryStream<T>(fn: () => Promise<T>): Promise<T>;
  * @returns `true` if webhook signature is valid and body is safe to parse.
  */
 export declare function isWebhookValid(body: string, secret: string, signature: string): boolean;
+/**
+ * Formats a number in seconds as a time formatted string.
+ * @param seconds number of seconds to be formatted
+ * @returns `string` in the form of HH:MM:SS based on input
+ */
+export declare function formatTime(seconds: number): string;