feat: client secret auth

scottdurow · scottdurow · commit 63083a206af5 · 2023-03-16T17:18:14.000-07:00
diff --git a/.dataverse-gen.json b/.dataverse-gen.json
@@ -9,5 +9,6 @@
     "outputRoot": "./src/dataverse-gen"
   },
   "generateIndex": false,
-  "generateFormContext": false
+  "generateFormContext": false,
+  "generateEntityTypes": true
 }
diff --git a/src/DataverseGenArgs.ts b/src/DataverseGenArgs.ts
@@ -0,0 +1,43 @@
+/* eslint-disable sonarjs/cognitive-complexity */
+import * as minimist from "minimist";
+import { DataverseMetadataService } from "./MetadataService";
+export enum DataverseGenCommands {
+  Init = "init",
+  Eject = "eject",
+  Help = "help",
+}
+const commands: string[] = [DataverseGenCommands.Init, DataverseGenCommands.Eject, DataverseGenCommands.Help];
+
+export class DataverseGenArgs {
+  constructor(processArgs: string[]) {
+    const args = minimist(processArgs, {
+      alias: { environment: "e", tenantId: "t", applicationId: "a", clientSecret: "s" },
+    });
+    this.verboseLogging = args.verbose || args.v || false;
+    this.environmentUrl = args.u || args.e;
+    this.tenantId = args.t;
+    this.applicationId = args.applicationId || args.a;
+    this.clientSecret = args.clientSecret || args.s || args.cs;
+    this.command = processArgs.find((a) => commands.indexOf(a) > -1);
+  }
+
+  public outputHelp() {
+    console.log("Usage: npx dataverse-get [command] [-u] [-t] [-a] [-cs]");
+    console.log("  dataverse-gen : Generates from an existing .dataverse-gen.json file");
+    console.log("  dataverse-gen init  : Adds .dataverse-gen.json config file to your project");
+    console.log("  dataverse-gen eject : Adds the templates to your project to allow you to customize them!");
+    console.log("  -u:  Optional: The url of the environment to connect to e.g. 'https://myorg.crm.dynamics.com'.");
+    console.log("       If not provided, the environment is selected from the list created using dataverse-auth");
+    console.log("  -t:  Optional: The Tenant Id if using an application user to connect.");
+    console.log("  -a:  Optional: The Application Id if using an application user to connect.");
+    console.log("  -s:  Optional: The Client Secret if using an application user to connect.");
+  }
+
+  public connectedService?: DataverseMetadataService;
+  public command?: string;
+  public environmentUrl: string;
+  public tenantId?: string;
+  public applicationId?: string;
+  public clientSecret?: string;
+  public verboseLogging = false;
+}
diff --git a/src/MetadataService.ts b/src/MetadataService.ts
@@ -27,13 +27,17 @@ export class DataverseMetadataService implements MetadataService {
     this.logger = logger || DefaultLogger;
   }
 
-  async authorize(server: string) {
+  async authorize(server: string, tenant?: string, appid?: string, secret?: string) {
     // Clear cache
     this.edmx = undefined;
     this.entityMetadataCache = {};
     this.server = server;
     this.webApi = new NodeWebApi(server);
-    await this.webApi.authorize();
+    if (appid && tenant && secret) {
+      await this.webApi.authorizeWithSecret(tenant, appid, secret);
+    } else {
+      await this.webApi.authorize();
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     this.client = new XrmContextDataverseClient(this.webApi as any as Xrm.WebApi);
     // Set Metadata
diff --git a/src/__tests__/helpers.ts b/src/__tests__/helpers.ts
@@ -2,11 +2,12 @@ import * as fs from "fs";
 import * as path from "path";
 import { CodeWriter } from "../CodeWriter";
 import { DataverseGenOptions } from "../MetadataGeneratorConfig";
-import { MetadataService } from "../MetadataService";
+import { DataverseMetadataService, MetadataService } from "../MetadataService";
 import { SchemaModel } from "../SchemaModel";
 import { FileSystemTemplateProvider } from "../TemplateProvider";
 import { TypescriptGenerator } from "../TypescriptGenerator";
 import { ILoggerCallback } from "../Logger";
+import { getServerConfig } from "dataverse-ify/lib/webapi/node";
 
 export async function getModel(options: DataverseGenOptions) {
   const projectDir = path.resolve(".");
@@ -46,3 +47,10 @@ export async function generateWithModel(defaultOptions: DataverseGenOptions, mod
 export const NoLogging: ILoggerCallback = () => {
   //noop
 };
+
+export async function getAuthorizedMetadataService() {
+  const config = getServerConfig();
+  const service = new DataverseMetadataService(NoLogging);
+  await service.authorize(config.host, config.tenant, config.appid, config.secret);
+  return service;
+}
diff --git a/src/__tests__/integration.metadata-service.test.ts b/src/__tests__/integration.metadata-service.test.ts
@@ -1,26 +1,19 @@
-import { getServerConfig } from "dataverse-ify/lib/webapi/node";
-import { DataverseMetadataService } from "../MetadataService";
 import * as path from "path";
 import * as fs from "fs";
-import { NoLogging } from "./helpers";
+import { getAuthorizedMetadataService } from "./helpers";
 
 describe("MetadataService", () => {
-  const config = getServerConfig();
   const projectDir = path.resolve(".");
 
   it("downloads EMDX", async () => {
-    const service = new DataverseMetadataService(NoLogging);
-    const server = config.host as string;
-    await service.authorize(server);
+    const service = await getAuthorizedMetadataService();
     const edmx = await service.getEdmxMetadata();
     expect(edmx).toBeDefined();
     fs.writeFileSync(path.join(projectDir, "src/__tests__/data/edmx.xml"), edmx);
   }, 1000000);
 
   it("downloads entity metadata", async () => {
-    const service = new DataverseMetadataService(NoLogging);
-    const server = config.host as string;
-    await service.authorize(server);
+    const service = await getAuthorizedMetadataService();
     const metadata = await service.getEntityMetadata("account");
     metadata.ServerVersionStamp = undefined;
 
@@ -59,9 +52,7 @@ describe("MetadataService", () => {
   }, 1000000);
 
   it("handles unknown entities", async () => {
-    const service = new DataverseMetadataService(NoLogging);
-    const server = config.host as string;
-    await service.authorize(server);
+    const service = await getAuthorizedMetadataService();
     const entityMetadata = await service.getEntityMetadata("foo");
     expect(entityMetadata.EntityMetadata).toHaveLength(0);
   });
diff --git a/src/__tests__/integration.schema-model.test.ts b/src/__tests__/integration.schema-model.test.ts
@@ -1,15 +1,11 @@
-import { getServerConfig } from "dataverse-ify/lib/webapi/node";
 import { DataverseMetadataService } from "../MetadataService";
 import { SchemaModel } from "../SchemaModel";
-import { NoLogging } from "./helpers";
+import { getAuthorizedMetadataService } from "./helpers";
 
 describe("SchemaModel", () => {
-  const config = getServerConfig();
   let service: DataverseMetadataService;
   beforeAll(async () => {
-    const server = config.host as string;
-    service = new DataverseMetadataService(NoLogging);
-    await service.authorize(server);
+    service = await getAuthorizedMetadataService();
     await service.getEdmxMetadata();
   }, 100000);
 
diff --git a/src/index.ts b/src/index.ts
@@ -5,9 +5,9 @@ import * as chalk from "chalk";
 import { getAllUsers } from "dataverse-ify/lib/webapi/node/MsalAuth";
 import * as Enquirer from "enquirer";
 import * as fs from "fs-extra";
-import * as minimist from "minimist";
 import * as path from "path";
 import { FileSystemCodeWriter } from "./CodeWriter";
+import { DataverseGenArgs, DataverseGenCommands } from "./DataverseGenArgs";
 import { DataverseGenOptions } from "./MetadataGeneratorConfig";
 import { DataverseMetadataService, MetadataService } from "./MetadataService";
 import { SchemaModel } from "./SchemaModel";
@@ -57,32 +57,38 @@ function saveConfig(
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
 
-function help(): void {
-  console.log("  dataverse-gen init  : Adds .dataverse-gen.json config file to your project");
-  console.log("  dataverse-gen eject : Adds the templates to your project to allow you to customize them!");
+async function GetMetadataService(args: DataverseGenArgs): Promise<DataverseMetadataService> {
+  const metadataService = new DataverseMetadataService();
+  if (args.environmentUrl && args.applicationId && args.tenantId && args.clientSecret) {
+    console.log(chalk.yellow("Using Client Secret Auth"));
+    await metadataService.authorize(args.environmentUrl, args.tenantId, args.applicationId, args.clientSecret);
+  } else if (args.environmentUrl) {
+    await metadataService.authorize(args.environmentUrl);
+  } else {
+    const server = await selectServer();
+    args.environmentUrl = "https://" + server;
+    await metadataService.authorize(args.environmentUrl);
+  }
+  return metadataService;
 }
 
-async function init(): Promise<void> {
+async function init(args: DataverseGenArgs): Promise<void> {
   const pathToTemplate = path.resolve(packageDir, "../.dataverse-gen.template.json");
   const pathToOutput = path.resolve(projectDir, configFileName);
 
   initDataverseGenConfig(pathToOutput, pathToTemplate);
 
-  const server = await selectServer();
-  if (server) {
-    // Load EDMX
-    const metadataService = new DataverseMetadataService();
-    await metadataService.authorize("https://" + server);
+  // Load EDMX
+  const metadataService = await GetMetadataService(args);
 
-    // Load existing config (if there is one)
-    const currentConfig = readConfig();
-    const updates = await updateConfig(currentConfig, metadataService);
+  // Load existing config (if there is one)
+  const currentConfig = readConfig();
+  const updates = await updateConfig(currentConfig, metadataService);
 
-    saveConfig(currentConfig, updates);
+  saveConfig(currentConfig, updates);
 
-    if (await generateNow()) {
-      await generate(server);
-    }
+  if (await generateNow()) {
+    await generate(args);
   }
 }
 
@@ -230,19 +236,15 @@ function eject(): void {
   fs.copySync(source, target);
 }
 
-async function generate(server?: string): Promise<void> {
-  const selectedServer = server || (await selectServer());
+async function generate(args: DataverseGenArgs): Promise<void> {
+  const metadataService = args.connectedService || (await GetMetadataService(args));
   const config: DataverseGenOptions = readConfig();
-  if (selectedServer) {
-    const metadataService = new DataverseMetadataService();
-    await metadataService.authorize("https://" + selectedServer);
-    const codeWriter = new FileSystemCodeWriter(config);
-    const templateProvider = new FileSystemTemplateProvider(config);
-    const model = new SchemaModel(metadataService, config);
-    await model.generate();
-    const codeGenerator = new TypescriptGenerator(model, codeWriter, templateProvider, config);
-    await codeGenerator.generate();
-  }
+  const codeWriter = new FileSystemCodeWriter(config);
+  const templateProvider = new FileSystemTemplateProvider(config);
+  const model = new SchemaModel(metadataService, config);
+  await model.generate();
+  const codeGenerator = new TypescriptGenerator(model, codeWriter, templateProvider, config);
+  await codeGenerator.generate();
 }
 
 async function selectServer(): Promise<string | undefined> {
@@ -296,23 +298,19 @@ async function main(): Promise<void> {
   console.log(`dataverse-gen v${version}`);
   console.log(chalk.gray("Running from package:" + packageDir));
 
-  const args = minimist(process.argv.slice(2));
-  // Check command arg
-  const mainArg = args._ && args._[0];
-  switch (mainArg) {
-    case "help":
-    case "h":
-    case "?":
-      help();
+  const args = new DataverseGenArgs(process.argv.slice(2));
+  switch (args.command) {
+    case DataverseGenCommands.Help:
+      args.outputHelp();
       break;
-    case "init":
-      await init();
+    case DataverseGenCommands.Init:
+      await init(args);
       break;
-    case "eject":
+    case DataverseGenCommands.Eject:
       eject();
       break;
     default:
-      await generate(args.s);
+      await generate(args);
       break;
   }
 }
@@ -322,8 +320,10 @@ main().then(
     console.log(chalk.green("\nComplete!"));
   },
   (ex) => {
-    if (ex.message) {
-      console.log(chalk.red(`\nError:${ex.message}`));
+    const message = ex.message || ex;
+
+    console.log(chalk.red(`\nError:${message}`));
+    if (ex.stack) {
       console.log(`Stack:${ex.stack}`);
       console.log(JSON.stringify(ex));
     }

Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,6 @@`
`9`	`9`	`"outputRoot": "./src/dataverse-gen"`
`10`	`10`	`},`
`11`	`11`	`"generateIndex": false,`
`12`		`- "generateFormContext": false`
	`12`	`+ "generateFormContext": false,`
	`13`	`+ "generateEntityTypes": true`
`13`	`14`	`}`