@ogcio/building-blocks-sdk 0.0.1

package/src/cli/update-clients-command.ts

@@ -0,0 +1,298 @@
+import fs from "node:fs";
+import { Command } from "commander";
+import openapiTS, { astToString } from "openapi-typescript";
+import { parse } from "yaml";
+import {
+  type ConfigurationBuildingBlock,
+  OpenAPIFileFormats,
+  readConfigurationFile,
+} from "../clients-configurations/read-configuration-file.js";
+import getAbsolutePath from "../utils/get-absolute-path.js";
+import {
+  CLIENTS_ROOT_FOLDER_PATH,
+  OLD_OPEN_API_DEFINITION_FILE_NAME,
+  OLD_SCHEMA_FILE_NAME,
+  OPEN_API_DEFINITION_FILE_NAME,
+  SCHEMA_FILE_NAME,
+  getOpenApiDefinitionFileContent,
+} from "./cli-utils.js";
+
+/**
+ * This command, starting from a json configuration file,
+ * downloads the open-API definition file,
+ * stores it in a folder with the building block name,
+ * then creates the Typescript schema and stores it in the same folder
+ */
+
+type FileBackup = {
+  oldPath: string | null;
+  newPath: string | null;
+};
+
+function log(message: string, ...params: unknown[]): void {
+  if (params.length === 0) {
+    console.log(`Update Clients: ${message}`);
+    return;
+  }
+  console.log(`Update Clients: ${message}`, params);
+}
+
+async function storeOpenApiDefinitionFile({
+  inputBuildingBlock,
+  dryRun,
+}: {
+  inputBuildingBlock: ConfigurationBuildingBlock;
+  dryRun: boolean;
+}): Promise<{
+  filePath: string;
+  fileContent: string;
+  buildingBlockFolder: string;
+  fileBackup: FileBackup;
+}> {
+  log(`${inputBuildingBlock.name} - Downloading Open API definition file`);
+  const downloadedFileContent = await getOpenApiDefinitionFileContent(
+    inputBuildingBlock.openApiDefinitionUrl,
+  );
+  log(`${inputBuildingBlock.name} - Open API definition file downloaded`);
+  const openApiParsed =
+    inputBuildingBlock.openApiDefinitionFormat === OpenAPIFileFormats.JSON
+      ? JSON.parse(downloadedFileContent)
+      : parse(downloadedFileContent);
+  log(`${inputBuildingBlock.name} - Open API definition file parsed`);
+
+  const serviceFolderPath = getAbsolutePath(
+    CLIENTS_ROOT_FOLDER_PATH,
+    inputBuildingBlock.name,
+  );
+
+  if (!fs.existsSync(serviceFolderPath) && !dryRun) {
+    fs.mkdirSync(serviceFolderPath, { recursive: true });
+  }
+
+  const stringifiedOpenApi = JSON.stringify(openApiParsed, null, 2);
+  const storedDefinitionFilePath = getAbsolutePath(
+    serviceFolderPath,
+    OPEN_API_DEFINITION_FILE_NAME,
+  );
+  const oldFilePath = getAbsolutePath(
+    serviceFolderPath,
+    OLD_OPEN_API_DEFINITION_FILE_NAME,
+  );
+
+  log(`${inputBuildingBlock.name} - Storing Open API definition file`);
+  let fileBackup: FileBackup = { newPath: null, oldPath: null };
+  if (!dryRun) {
+    fileBackup = storeFilesWithBackup({
+      oldPath: oldFilePath,
+      latestVersionContent: stringifiedOpenApi,
+      latestVersionPath: storedDefinitionFilePath,
+    });
+  }
+  log(
+    `${inputBuildingBlock.name} - Open API definition file stored!`,
+    fileBackup,
+  );
+
+  return {
+    fileContent: stringifiedOpenApi,
+    filePath: storedDefinitionFilePath,
+    buildingBlockFolder: serviceFolderPath,
+    fileBackup,
+  };
+}
+
+async function storeSchema({
+  openApiDefinitionContent,
+  buildingBlockFolder,
+  inputBuildingBlock,
+  dryRun,
+}: {
+  openApiDefinitionContent: string;
+  buildingBlockFolder: string;
+  inputBuildingBlock: ConfigurationBuildingBlock;
+  dryRun: boolean;
+}): Promise<FileBackup> {
+  log(`${inputBuildingBlock.name} - Creating TS Schema`);
+  const parser = await openapiTS(openApiDefinitionContent);
+  const parsedSchema = astToString(parser);
+  log(`${inputBuildingBlock.name} - TS Schema created`);
+  const schemaFilePath = getAbsolutePath(buildingBlockFolder, SCHEMA_FILE_NAME);
+  const oldPath = getAbsolutePath(buildingBlockFolder, OLD_SCHEMA_FILE_NAME);
+
+  log(`${inputBuildingBlock.name} - Storing TS Schema`);
+  let fileBackup: FileBackup = { newPath: null, oldPath: null };
+  if (!dryRun) {
+    fileBackup = storeFilesWithBackup({
+      oldPath,
+      latestVersionContent: parsedSchema,
+      latestVersionPath: schemaFilePath,
+    });
+  }
+  log(`${inputBuildingBlock.name} - TS Schema stored`);
+
+  return fileBackup;
+}
+
+function deleteOldFiles(
+  buildingBlockName: string,
+  ...backedUpFiles: FileBackup[]
+): void {
+  for (const backedUp of backedUpFiles) {
+    try {
+      // if an old version has been backupped
+      // but all went fine, delete it
+      if (backedUp.oldPath) {
+        fs.unlinkSync(backedUp.oldPath);
+      }
+    } catch (e) {
+      log(`${buildingBlockName} - Error deleting ${backedUp.oldPath}`, e);
+    }
+  }
+}
+
+function restoreOldFiles(
+  buildingBlockName: string,
+  ...backedUpFiles: FileBackup[]
+): void {
+  for (const backedUp of backedUpFiles) {
+    try {
+      if (backedUp.oldPath) {
+        // if a backup is available and the
+        // new file has been written
+        // revert it
+        if (backedUp.newPath) {
+          fs.copyFileSync(backedUp.oldPath, backedUp.newPath);
+        }
+        fs.unlinkSync(backedUp.oldPath);
+      } else if (backedUp.newPath) {
+        // if the new file has been saved
+        // and something went wrong
+        // delete it
+        fs.unlinkSync(backedUp.newPath);
+      }
+    } catch (e) {
+      log(`${buildingBlockName} - Error restoring ${backedUp.newPath}`, e);
+    }
+  }
+}
+
+function storeFilesWithBackup({
+  oldPath,
+  latestVersionPath,
+  latestVersionContent,
+}: {
+  oldPath: string;
+  latestVersionPath: string;
+  latestVersionContent: string;
+}): FileBackup {
+  const output: FileBackup = { newPath: null, oldPath: null };
+  // if the file already exists
+  // backup it
+  if (fs.existsSync(latestVersionPath)) {
+    output.oldPath = oldPath;
+    fs.copyFileSync(latestVersionPath, oldPath);
+  }
+  // write the new file
+  fs.writeFileSync(latestVersionPath, latestVersionContent);
+  output.newPath = latestVersionPath;
+
+  return output;
+}
+
+async function processBuildingBlock({
+  inputBuildingBlock,
+  dryRun,
+}: {
+  inputBuildingBlock: ConfigurationBuildingBlock;
+  dryRun: boolean;
+}): Promise<void> {
+  let schemaFileBackup: FileBackup = {
+    oldPath: null,
+    newPath: null,
+  };
+  let storedDefinition = null;
+  if (inputBuildingBlock.updateDefinitions === false) {
+    log(`${inputBuildingBlock.name} - Update definition is disabled, ignoring`);
+    return;
+  }
+  log(`${inputBuildingBlock.name} - Processing`);
+  try {
+    storedDefinition = await storeOpenApiDefinitionFile({
+      inputBuildingBlock,
+      dryRun,
+    });
+    schemaFileBackup = await storeSchema({
+      inputBuildingBlock,
+      openApiDefinitionContent: storedDefinition.fileContent,
+      buildingBlockFolder: storedDefinition.buildingBlockFolder,
+      dryRun,
+    });
+
+    log(`${inputBuildingBlock.name} - Deleting backup files`);
+    if (!dryRun) {
+      deleteOldFiles(
+        inputBuildingBlock.name,
+        storedDefinition.fileBackup,
+        schemaFileBackup,
+      );
+    }
+  } catch (e) {
+    log(
+      `${inputBuildingBlock.name} - Error While Processing, restoring backups`,
+    );
+    if (!dryRun) {
+      restoreOldFiles(
+        inputBuildingBlock.name,
+        storedDefinition?.fileBackup ?? { newPath: null, oldPath: null },
+        schemaFileBackup,
+      );
+    }
+
+    throw e;
+  }
+  log(`${inputBuildingBlock.name} - Processed`);
+}
+
+async function updateClients({
+  configurationFilePath,
+  dryRun,
+}: { configurationFilePath: string; dryRun?: boolean }): Promise<void> {
+  dryRun = dryRun ?? false;
+  const configurationFile = await readConfigurationFile(configurationFilePath);
+  log("Configuration file read");
+
+  const promises: Promise<void>[] = [];
+  for (const inputBuilding of Object.values(configurationFile.buildingBlocks)) {
+    promises.push(
+      processBuildingBlock({ inputBuildingBlock: inputBuilding, dryRun }),
+    );
+  }
+
+  await Promise.all(promises);
+}
+
+const updateClientsCommand = new Command("clients:update");
+updateClientsCommand
+  .description(
+    "Parse a configuration file to update the info related to the clients",
+  )
+  .requiredOption(
+    "-c, --configuration-file-path <configuration-path>",
+    "Path of the configuration file to parse",
+    (value: string) => getAbsolutePath(value),
+  )
+  .option("--dry-run", "Simulate the command without executing it")
+  .action(
+    async (options: { configurationFilePath: string; dryRun?: boolean }) => {
+      log("Started!");
+      if (options.dryRun) {
+        log(
+          "Alert. I am running dry! Changes will be logged only, not applied!",
+        );
+      }
+      await updateClients(options);
+      log("Ended!");
+    },
+  );
+
+export default updateClientsCommand;

package/src/client/auth/index.ts

@@ -0,0 +1,131 @@
+import configFile from "../../clients-configurations/clients-configuration.json";
+import type {
+  GetAccessTokenParams,
+  GetOrganizationTokenParams,
+  M2MTokenFnConfig,
+  SERVICE_NAME,
+  TokenFunction,
+  TokenResponseBody,
+} from "../../types/index.js";
+
+const fetchToken = async (params: {
+  logtoOidcEndpoint: string;
+  applicationId: string;
+  applicationSecret: string;
+  scopes: string[];
+  specificBodyFields: { [x: string]: string };
+}) => {
+  const body = {
+    ...params.specificBodyFields,
+    scope: params.scopes.join(" "),
+    grant_type: "client_credentials",
+  };
+  const logtoOidcEndpoint = params.logtoOidcEndpoint.endsWith("/")
+    ? params.logtoOidcEndpoint
+    : `${params.logtoOidcEndpoint}/`;
+  const response = await fetch(`${logtoOidcEndpoint}token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Basic ${Buffer.from(
+        `${params.applicationId}:${params.applicationSecret}`,
+      ).toString("base64")}`,
+    },
+    body: new URLSearchParams(body).toString(),
+  });
+
+  if (response.status !== 200) {
+    throw new Error("Unauthorized");
+  }
+
+  return response.json() as Promise<TokenResponseBody>;
+};
+
+const getAccessToken = async (
+  params: GetAccessTokenParams,
+  scopes: string[],
+) => {
+  const scopesToUse = params.scopes || scopes;
+
+  const tokenResponse = await fetchToken({
+    ...params,
+    scopes: scopesToUse,
+    specificBodyFields: { resource: params.resource },
+  });
+  return tokenResponse.access_token;
+};
+
+const getOrganizationToken = async (
+  params: GetOrganizationTokenParams,
+  scopes: string[],
+) => {
+  const logtoUserScopes = await importUserScopes();
+
+  const { UserScope } = logtoUserScopes;
+
+  const scopesToUse = params.scopes || scopes;
+
+  const tokenResponse = await fetchToken({
+    ...params,
+    scopes: [
+      ...scopesToUse,
+      UserScope.OrganizationRoles,
+      UserScope.Organizations,
+    ],
+    specificBodyFields: {
+      organization_id: params.organizationId,
+    },
+  });
+  return tokenResponse.access_token;
+};
+
+const importUserScopes = async () => {
+  try {
+    const { UserScope } = await import("@logto/node");
+
+    return { UserScope };
+  } catch {
+    throw new Error("@logto/node package is not installed!");
+  }
+};
+
+const getM2MTokenFn = (m2mTokenConfig: M2MTokenFnConfig): TokenFunction => {
+  const { services } = m2mTokenConfig;
+
+  const tokenFn = (serviceName: SERVICE_NAME) => {
+    const serviceParams = services[serviceName];
+
+    // const scopes = configFile.buildingBlocks[serviceName];
+
+    const serviceConfig = configFile.buildingBlocks.find(
+      ({ name }) => name === serviceName,
+    );
+
+    if (!serviceConfig) {
+      throw new Error(`Missing client config for ${serviceName}`);
+    }
+
+    if (!serviceParams) {
+      throw new Error(`Missing m2m config for ${serviceName}`);
+    }
+
+    const { getAccessTokenParams, getOrganizationTokenParams } = serviceParams;
+    if (getAccessTokenParams) {
+      return getAccessToken(
+        getAccessTokenParams,
+        serviceConfig.citizenPermissions,
+      );
+    }
+    if (getOrganizationTokenParams) {
+      return getOrganizationToken(
+        getOrganizationTokenParams,
+        serviceConfig.publicServantPermissions,
+      );
+    }
+
+    throw new Error(`wrong m2m config for ${serviceName}`);
+  };
+  return tokenFn;
+};
+
+export default getM2MTokenFn;

package/src/client/base-client.ts

@@ -0,0 +1,97 @@
+import createClient, {
+  type Middleware,
+  type FetchResponse,
+} from "openapi-fetch";
+import type {
+  ApiClientParams,
+  SERVICE_NAME,
+  TokenFunction,
+} from "../types/index.js";
+import type { DataResponseValue } from "./utils/client-utils.js";
+
+abstract class BaseClient<T extends {}> {
+  private baseUrl?: string;
+  private initialized;
+
+  protected token?: string;
+  protected getTokenFn?: TokenFunction;
+  protected serviceName: SERVICE_NAME | undefined;
+
+  protected client: ReturnType<typeof createClient<T>>;
+
+  constructor({ baseUrl, getTokenFn }: ApiClientParams) {
+    this.initialized = false;
+    if (baseUrl) {
+      this.baseUrl = baseUrl;
+      this.initialized = true;
+    }
+
+    if (getTokenFn) {
+      this.getTokenFn = getTokenFn;
+    }
+
+    this.token = undefined;
+    this.client = createClient<T>({ baseUrl: this.baseUrl });
+    const authMiddleware: Middleware = {
+      onRequest: async ({ request }) => {
+        if (!this.token && this.getTokenFn) {
+          this.token = await this.getTokenFn(this.serviceName as SERVICE_NAME);
+        }
+
+        if (this.token) {
+          request.headers.set("Authorization", `Bearer ${this.token}`);
+        }
+        return request;
+      },
+    };
+
+    this.client.use(authMiddleware);
+  }
+
+  protected async getToken() {
+    if (this.getTokenFn) {
+      const token = await this.getTokenFn(this.serviceName as SERVICE_NAME);
+      this.token = token;
+    }
+
+    return this.token;
+  }
+
+  public isInitialized() {
+    return this.initialized;
+  }
+
+  protected formatResponse<G, O>(
+    response: FetchResponse<G, O, "application/json">,
+  ): DataResponseValue<G, O> {
+    let outputData = undefined;
+    let outputMetadata = undefined;
+    if (!response) {
+      return {} as DataResponseValue<G, O>;
+    }
+    if (response.data) {
+      const dataEntries = Object.entries(response.data);
+      // by docs the body should contain a "data"
+      // properties with the response values
+      const containsData = dataEntries.find((x) => x[0] === "data");
+      const containsMetadata = dataEntries.find((x) => x[0] === "metadata");
+
+      if (containsMetadata) {
+        outputMetadata = containsMetadata[1];
+      }
+      outputData = containsData ? containsData[1] : response.data;
+    }
+
+    return {
+      data: outputData,
+      metadata: outputMetadata,
+      error: response.error,
+    } as unknown as DataResponseValue<G, O>;
+  }
+
+  protected formatError<G, O>(reason: unknown): DataResponseValue<G, O> {
+    return { error: reason } as unknown as DataResponseValue<G, O>;
+  }
+}
+
+export default BaseClient;