Migrates 'entra administrative unit get' to Zod

Author: martinlingstuyl

src/m365/entra/commands/administrativeunit/administrativeunit-get.spec.ts

@@ -1,5 +1,6 @@
 import assert from 'assert';
 import sinon from "sinon";
+import { z } from 'zod';
 import auth from '../../../../Auth.js';
 import { CommandInfo } from "../../../../cli/CommandInfo.js";
 import { Logger } from "../../../../cli/Logger.js";
@@ -19,6 +20,7 @@ describe(commands.ADMINISTRATIVEUNIT_GET, () => {
   let logger: Logger;
   let loggerLogSpy: sinon.SinonSpy;
   let commandInfo: CommandInfo;
+  let commandOptionsSchema: z.ZodTypeAny;
   const administrativeUnitsReponse = {
     value: [
       {
@@ -43,6 +45,7 @@ describe(commands.ADMINISTRATIVEUNIT_GET, () => {
     sinon.stub(session, 'getId').returns('');
     auth.connection.active = true;
     commandInfo = cli.getCommandInfo(command);
+    commandOptionsSchema = commandInfo.command.getSchemaToParse()!;
   });
 
   beforeEach(() => {
@@ -82,6 +85,32 @@ describe(commands.ADMINISTRATIVEUNIT_GET, () => {
     assert.notStrictEqual(command.description, null);
   });
 
+  it('fails validation when id or displayName are not specified', () => {
+    const actual = commandOptionsSchema.safeParse({});
+    assert.strictEqual(actual.success, false);
+  });
+
+  it('passes validation when id is specified', () => {
+    const actual = commandOptionsSchema.safeParse({
+      id: validId
+    });
+    assert.strictEqual(actual.success, true);
+  });
+
+  it('passes validation when displayName is specified', () => {
+    const actual = commandOptionsSchema.safeParse({
+      displayName: validDisplayName
+    });
+    assert.strictEqual(actual.success, true);
+  });
+
+  it('fails validation if the id is not a valid GUID', () => {
+    const actual = commandOptionsSchema.safeParse({
+      id: '123'
+    });
+    assert.strictEqual(actual.success, false);
+  });
+
   it('retrieves information about the specified administrative unit by id', async () => {
     sinon.stub(request, 'get').callsFake(async (opts) => {
       if (opts.url === `https://graph.microsoft.com/v1.0/directory/administrativeUnits/${validId}`) {
@@ -91,7 +120,7 @@ describe(commands.ADMINISTRATIVEUNIT_GET, () => {
       throw 'Invalid request';
     });
 
-    await command.action(logger, { options: { id: validId } });
+    await command.action(logger, { options: commandOptionsSchema.parse({ id: validId }) });
     assert(loggerLogSpy.calledOnceWithExactly(administrativeUnitsReponse.value[0]));
   });
 
@@ -104,36 +133,21 @@ describe(commands.ADMINISTRATIVEUNIT_GET, () => {
       throw 'Invalid request';
     });
 
-    await command.action(logger, { options: { id: validId, properties: 'id,displayName,visibility' } });
+    await command.action(logger, { options: commandOptionsSchema.parse({ id: validId, properties: 'id,displayName,visibility' }) });
     assert(loggerLogSpy.calledOnceWithExactly(administrativeUnitsReponse.value[0]));
   });
 
   it('retrieves information about the specified administrative unit by displayName', async () => {
     sinon.stub(entraAdministrativeUnit, 'getAdministrativeUnitByDisplayName').resolves(administrativeUnitsReponse.value[0]);
 
-    await command.action(logger, { options: { displayName: validDisplayName } });
+    await command.action(logger, { options: commandOptionsSchema.parse({ displayName: validDisplayName }) });
     assert(loggerLogSpy.calledOnceWithExactly(administrativeUnitsReponse.value[0]));
   });
 
   it('handles random API error', async () => {
     const errorMessage = 'Something went wrong';
     sinon.stub(request, 'get').rejects(new Error(errorMessage));
 
-    await assert.rejects(command.action(logger, { options: { id: validId } }), new CommandError(errorMessage));
-  });
-
-  it('fails validation if the id is not a valid GUID', async () => {
-    const actual = await command.validate({ options: { id: '123' } }, commandInfo);
-    assert.notStrictEqual(actual, true);
-  });
-
-  it('passes validation if the id is a valid GUID', async () => {
-    const actual = await command.validate({ options: { id: validId } }, commandInfo);
-    assert.strictEqual(actual, true);
-  });
-
-  it('passes validation if required options specified (displayName)', async () => {
-    const actual = await command.validate({ options: { displayName: validDisplayName } }, commandInfo);
-    assert.strictEqual(actual, true);
+    await assert.rejects(command.action(logger, { options: commandOptionsSchema.parse({ id: validId }) }), new CommandError(errorMessage));
   });
 });

src/m365/entra/commands/administrativeunit/administrativeunit-get.ts

@@ -1,22 +1,27 @@
 import { AdministrativeUnit } from "@microsoft/microsoft-graph-types";
-import GlobalOptions from "../../../../GlobalOptions.js";
+import { z } from 'zod';
 import { Logger } from "../../../../cli/Logger.js";
-import { validation } from "../../../../utils/validation.js";
 import request, { CliRequestOptions } from "../../../../request.js";
 import GraphCommand from "../../../base/GraphCommand.js";
 import commands from "../../commands.js";
 import { entraAdministrativeUnit } from "../../../../utils/entraAdministrativeUnit.js";
+import { globalOptionsZod } from "../../../../Command.js";
+import { zod } from "../../../../utils/zod.js";
+
+const options = globalOptionsZod
+  .extend({
+    id: zod.alias('i', z.string().uuid().optional()),
+    displayName: zod.alias('n', z.string().optional()),
+    properties: zod.alias('p', z.string().optional())
+  })
+  .strict();
+
+declare type Options = z.infer<typeof options>;
 
 interface CommandArgs {
   options: Options;
 }
 
-export interface Options extends GlobalOptions {
-  id?: string;
-  displayName?: string;
-  properties?: string;
-}
-
 class EntraAdministrativeUnitGetCommand extends GraphCommand {
   public get name(): string {
     return commands.ADMINISTRATIVEUNIT_GET;
@@ -26,58 +31,15 @@ class EntraAdministrativeUnitGetCommand extends GraphCommand {
     return 'Gets information about a specific administrative unit';
   }
 
-  constructor() {
-    super();
-
-    this.#initTelemetry();
-    this.#initOptions();
-    this.#initValidators();
-    this.#initOptionSets();
-    this.#initTypes();
+  public get schema(): z.ZodTypeAny | undefined {
+    return options;
   }
 
-  #initTelemetry(): void {
-    this.telemetry.push((args: CommandArgs) => {
-      Object.assign(this.telemetryProperties, {
-        id: typeof args.options.id !== 'undefined',
-        displayName: typeof args.options.displayName !== 'undefined',
-        properties: typeof args.options.properties !== 'undefined'
+  public getRefinedSchema(schema: typeof options): z.ZodEffects<any> | undefined {
+    return schema
+      .refine(options => [options.id, options.displayName].filter(Boolean).length === 1, {
+        message: 'Specify either id or displayName'
       });
-    });
-  }
-
-  #initOptions(): void {
-    this.options.unshift(
-      {
-        option: '-i, --id [id]'
-      },
-      {
-        option: '-n, --displayName [displayName]'
-      },
-      {
-        option: '-p, --properties [properties]'
-      }
-    );
-  }
-
-  #initValidators(): void {
-    this.validators.push(
-      async (args: CommandArgs) => {
-        if (args.options.id && !validation.isValidGuid(args.options.id as string)) {
-          return `${args.options.id} is not a valid GUID`;
-        }
-
-        return true;
-      }
-    );
-  }
-
-  #initOptionSets(): void {
-    this.optionSets.push({ options: ['id', 'displayName'] });
-  }
-
-  #initTypes(): void {
-    this.types.string.push('displayName');
   }
 
   public async commandAction(logger: Logger, args: CommandArgs): Promise<void> {