chore: stop using deprecated schemaValidator @W-20495414@

Author: jfeingold35

package.json

@@ -132,7 +132,8 @@
     "csv-parse": "^5.6.0",
     "csv-stringify": "^6.6.0",
     "form-data": "^4.0.5",
-    "terminal-link": "^3.0.0"
+    "terminal-link": "^3.0.0",
+    "zod": "^4.2.1"
   },
   "devDependencies": {
     "@oclif/core": "^4.8.0",

schema/dataImportPlanSchema.json

@@ -15,13 +15,13 @@
  */
 import path from 'node:path';
 import { EOL } from 'node:os';
-import { fileURLToPath } from 'node:url';
 import fs from 'node:fs';
 import { createHash } from 'node:crypto';
 
-import { AnyJson, isString } from '@salesforce/ts-types';
-import { Logger, SchemaValidator, SfError, Connection, Messages } from '@salesforce/core';
+import { isString } from '@salesforce/ts-types';
+import { Logger, Connection, Messages } from '@salesforce/core';
 import type { GenericObject, SObjectTreeInput } from '../../../types.js';
+import { DataImportPlanArraySchema, DataImportPlanArray } from '../../../schema/dataImportPlan.js';
 import type { DataPlanPartFilesOnly, ImportResult } from './importTypes.js';
 import {
   getResultsIfNoError,
@@ -56,14 +56,10 @@ export const importFromPlan = async (conn: Connection, planFilePath: string): Pr
   const logger = Logger.childFromRoot('data:import:tree:importFromPlan');
 
   const planContents = await Promise.all(
-    (
-      await validatePlanContents(logger)(
-        resolvedPlanPath,
-        (await JSON.parse(fs.readFileSync(resolvedPlanPath, 'utf8'))) as DataPlanPartFilesOnly[]
+    _validatePlanContents(logger, resolvedPlanPath, JSON.parse(fs.readFileSync(resolvedPlanPath, 'utf-8')))
+      .flatMap((planPart) =>
+        planPart.files.map((f) => ({ ...planPart, filePath: path.resolve(path.dirname(resolvedPlanPath), f) }))
       )
-    )
-      // there *shouldn't* be multiple files for the same sobject in a plan, but the legacy code allows that
-      .flatMap((dpp) => dpp.files.map((f) => ({ ...dpp, filePath: path.resolve(path.dirname(resolvedPlanPath), f) })))
       .map(async (i) => ({
         ...i,
         records: parseDataFileContents(i.filePath)(await fs.promises.readFile(i.filePath, 'utf-8')),
@@ -189,54 +185,35 @@ const replaceRefWithId =
       Object.entries(record).map(([k, v]) => [k, v === `@${ref.refId}` ? ref.id : v])
     ) as SObjectTreeInput;
 
-export const validatePlanContents =
-  (logger: Logger) =>
-  async (planPath: string, planContents: unknown): Promise<DataPlanPartFilesOnly[]> => {
-    const childLogger = logger.child('validatePlanContents');
-    const planSchema = path.join(
-      path.dirname(fileURLToPath(import.meta.url)),
-      '..',
-      '..',
-      '..',
-      '..',
-      'schema',
-      'dataImportPlanSchema.json'
-    );
+// eslint-disable-next-line no-underscore-dangle
+export function _validatePlanContents(logger: Logger, planPath: string, planContents: unknown): DataImportPlanArray {
+  const childLogger: Logger = logger.child('validatePlanContents');
 
-    const val = new SchemaValidator(childLogger, planSchema);
-    try {
-      await val.validate(planContents as AnyJson);
-      const output = planContents as DataPlanPartFilesOnly[];
-      if (hasRefs(output)) {
-        childLogger.warn(
-          "The plan contains the 'saveRefs' and/or 'resolveRefs' properties.  These properties will be ignored and can be removed."
-        );
-      }
-      if (!hasOnlySimpleFiles(output)) {
-        throw messages.createError('error.NonStringFiles');
-      }
-      return planContents as DataPlanPartFilesOnly[];
-    } catch (err) {
-      if (err instanceof Error && err.name === 'ValidationSchemaFieldError') {
-        throw messages.createError('error.InvalidDataImport', [planPath, err.message]);
-      } else if (err instanceof Error) {
-        throw SfError.wrap(err);
-      }
-      throw err;
+  const parseResults = DataImportPlanArraySchema.safeParse(planContents);
+
+  if (parseResults.error) {
+    throw messages.createError('error.InvalidDataImport', [
+      planPath,
+      parseResults.error.issues.map((e) => e.message).join('\n'),
+    ]);
+  }
+  const parsedPlans: DataImportPlanArray = parseResults.data;
+
+  for (const parsedPlan of parsedPlans) {
+    if (parsedPlan.saveRefs !== undefined || parsedPlan.resolveRefs !== undefined) {
+      childLogger.warn(
+        "The plan contains the 'saveRefs' and/or 'resolveRefs' properties. These properties will be ignored and can be removed."
+      );
     }
-  };
+  }
+  return parsedPlans;
+}
 
 const matchesRefFilter =
   (unresolvedRefRegex: RegExp) =>
   (v: unknown): boolean =>
     typeof v === 'string' && unresolvedRefRegex.test(v);
 
-const hasOnlySimpleFiles = (planParts: DataPlanPartFilesOnly[]): boolean =>
-  planParts.every((p) => p.files.every((f) => typeof f === 'string'));
-
-const hasRefs = (planParts: DataPlanPartFilesOnly[]): boolean =>
-  planParts.some((p) => p.saveRefs !== undefined || p.resolveRefs !== undefined);
-
 // TODO: change this implementation to use Object.groupBy when it's on all supported node versions
 const filterUnresolved = (
   records: SObjectTreeInput[]

src/api/data/tree/importPlan.ts

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Dictionary } from '@salesforce/ts-types';
 import type { DataPlanPart } from '../../../types.js';
 
 /*
@@ -48,11 +47,6 @@ export type ResponseRefs = {
   referenceId: string;
   id: string;
 };
-export type ImportResults = {
-  responseRefs?: ResponseRefs[];
-  sobjectTypes?: Dictionary;
-  errors?: string[];
-};
 
 export type ImportResult = {
   refId: string;

src/api/data/tree/importTypes.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+
+export const DataImportPlanArraySchema = z
+  .array(
+    z.object({
+      sobject: z.string().describe('Child file references must have SObject roots of this type'),
+      saveRefs: z
+        .boolean()
+        .optional()
+        .describe(
+          'Post-save, save references (Name/ID) to be used for reference replacement in subsequent saves.  Applies to all data files for this SObject type.'
+        ),
+      resolveRefs: z
+        .boolean()
+        .optional()
+        .describe(
+          'Pre-save, replace @<reference> with ID from previous save.  Applies to all data files for this SObject type.'
+        ),
+      files: z
+        .array(
+          z
+            .string('The `files` property of the plan objects must contain only strings')
+            .describe(
+              'Filepath string or object to point to a JSON or XML file having data defined in SObject Tree format.'
+            )
+        )
+        .describe('An array of files paths to load'),
+    })
+  )
+  .describe('Schema for data import plan JSON');
+
+export type DataImportPlanArray = z.infer<typeof DataImportPlanArraySchema>;

src/schema/dataImportPlan.ts

@@ -16,14 +16,14 @@
 /* eslint-disable camelcase */ // for salesforce __c style fields
 
 import { expect, assert } from 'chai';
-import { shouldThrow } from '@salesforce/core/testSetup';
+import { shouldThrowSync } from '@salesforce/core/testSetup';
 import { Logger } from '@salesforce/core';
 import {
   replaceRefsInTheSameFile,
   EnrichedPlanPart,
   replaceRefs,
   fileSplitter,
-  validatePlanContents,
+  _validatePlanContents,
 } from '../../../../src/api/data/tree/importPlan.js';
 
 describe('importPlan', () => {
@@ -124,8 +124,8 @@ describe('importPlan', () => {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       logger.memoryLogger.loggedData = [];
     });
-    const validator = validatePlanContents(logger);
-    it('good plan in classic format', async () => {
+
+    it('good plan in classic format, one file', () => {
       const plan = [
         {
           sobject: 'Account',
@@ -134,10 +134,12 @@ describe('importPlan', () => {
           files: ['Account.json'],
         },
       ];
-      expect(await validator('some/path', plan)).to.equal(plan);
+
+      expect(_validatePlanContents(logger, 'some/path', plan)).to.deep.equal(plan);
       expect(getLogMessages(logger)).to.include('saveRefs');
     });
-    it('good plan in classic format', async () => {
+
+    it('good plan in classic format, multiple files', () => {
       const plan = [
         {
           sobject: 'Account',
@@ -146,25 +148,28 @@ describe('importPlan', () => {
           files: ['Account.json', 'Account2.json'],
         },
       ];
-      expect(await validator('some/path', plan)).to.equal(plan);
+
+      expect(_validatePlanContents(logger, 'some/path', plan)).to.deep.equal(plan);
+      expect(getLogMessages(logger)).to.include('saveRefs');
     });
-    it('throws on bad plan (missing the object)', async () => {
+
+    it('throws on bad plan (missing sobject property)', () => {
       const plan = [
         {
           saveRefs: true,
           resolveRefs: true,
           files: ['Account.json', 'Account2.json'],
         },
       ];
+
       try {
-        await shouldThrow(validator('some/path', plan));
+        shouldThrowSync(() => _validatePlanContents(logger, 'some/path', plan));
       } catch (e) {
         assert(e instanceof Error);
         expect(e.name).to.equal('InvalidDataImportError');
       }
     });
-    // TODO: remove this test when schema moves to simple files only
-    it('throws when files are an object that meets current schema', async () => {
+    it('throws when files property contains non-strings', () => {
       const plan = [
         {
           sobject: 'Account',
@@ -174,20 +179,20 @@ describe('importPlan', () => {
         },
       ];
       try {
-        await shouldThrow(validator('some/path', plan));
+        shouldThrowSync(() => _validatePlanContents(logger, 'some/plan', plan));
       } catch (e) {
         assert(e instanceof Error);
-        expect(e.name, JSON.stringify(e)).to.equal('NonStringFilesError');
+        expect(e.message).to.include('The `files` property of the plan objects must contain only strings');
       }
     });
-    it('good plan in new format is valid and produces no warnings', async () => {
+    it('good plan in new format', () => {
       const plan = [
         {
           sobject: 'Account',
           files: ['Account.json'],
         },
       ];
-      expect(await validator('some/path', plan)).to.equal(plan);
+      expect(_validatePlanContents(logger, 'some/path', plan)).to.deep.equal(plan);
       expect(getLogMessages(logger)).to.not.include('saveRefs');
     });
   });

test/api/data/tree/importPlan.test.ts

@@ -7922,3 +7922,8 @@ zod@^4.1.12:
   version "4.1.13"
   resolved "https://registry.yarnpkg.com/zod/-/zod-4.1.13.tgz#93699a8afe937ba96badbb0ce8be6033c0a4b6b1"
   integrity sha512-AvvthqfqrAhNH9dnfmrfKzX5upOdjUVJYFqNSlkmGf64gRaTzlPwz99IHYnVs28qYAybvAlBV+H7pn0saFY4Ig==
+
+zod@^4.2.1:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/zod/-/zod-4.2.1.tgz#07f0388c7edbfd5f5a2466181cb4adf5b5dbd57b"
+  integrity sha512-0wZ1IRqGGhMP76gLqz8EyfBXKk0J2qo2+H3fi4mcUP/KtTocoX08nmIAHl1Z2kJIZbZee8KOpBCSNPRgauucjw==