@cirrobio/sdk 0.12.11 → 0.12.12

package/src/api/config.ts

@@ -0,0 +1,17 @@
+import { PortalErrorHandler } from "./error-handler";
+import { Configuration } from "@cirrobio/api-client";
+
+interface GetConfigParams {
+  tokenGetter: () => Promise<string>;
+  basePath?: string;
+}
+
+export const generateApiConfig = ({ basePath = "/api", tokenGetter}: GetConfigParams) => {
+  return new Configuration({
+    basePath,
+    accessToken: tokenGetter,
+    middleware: [
+      new PortalErrorHandler()
+    ],
+  });
+}

package/src/api/error-handler.ts

@@ -0,0 +1,28 @@
+import { Middleware, ResponseContext } from "@cirrobio/api-client";
+import { ApiError } from "./error";
+
+export class PortalErrorHandler implements Middleware {
+  async post(context: ResponseContext): Promise<Response | void> {
+    const { response } = context;
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+
+    // Handle Error
+    let errorMessage: string;
+    const errors = [];
+    try {
+      const err = await response.json();
+      console.warn(err);
+      if ('errorDetail' in err) {
+        errorMessage = err.errorDetail;
+        errors.push(err.errors.map((e: any) => e.message));
+      } else {
+        errorMessage = err.message;
+      }
+    } catch (ignore) {
+      errorMessage = "Unknown Error";
+    }
+    throw new ApiError(errorMessage, errors);
+  }
+}

package/src/api/error.ts

@@ -0,0 +1,8 @@
+export class ApiError extends Error {
+  errors: string[];
+
+  constructor(message: string, errors: string[]) {
+    super(message);
+    this.errors = errors;
+  }
+}

package/src/api.ts

@@ -0,0 +1,2 @@
+export { ApiError } from './api/error';
+export { generateApiConfig } from './api/config';

package/src/auth/authentication-provider.ts

@@ -0,0 +1,26 @@
+import { CurrentUser } from "./current-user";
+import { SystemInfoResponse } from "@cirrobio/api-client";
+
+
+/**
+ * AuthenticationProvider defines how the application will authenticate users to Cirro.
+ */
+export interface AuthenticationProvider {
+  /**
+   * Configures the authentication provider
+   */
+  configure: (config: SystemInfoResponse) => void;
+  /**
+   * Returns access token for the current user.
+   */
+  getAccessToken: () => Promise<string>;
+  /**
+   * Returns the current user information.
+   */
+  getCurrentUser: () => Promise<CurrentUser>;
+  /**
+   * Force a refresh of the authentication state.
+   * (i.e., pull a fresh access token to get the latest user info)
+   */
+  forceRefresh: () => Promise<void>;
+}

package/src/auth/current-user.ts

@@ -0,0 +1,26 @@
+export class CurrentUser {
+  username: string;
+  /**
+   * The unique identifier for the user
+   */
+  sub: string
+
+  /**
+   * The time the user authenticated
+   */
+  authTime: Date;
+
+  /**
+   * The groups the user belongs to
+   */
+  groups: string[];
+
+  static fromCognitoUser(idTokenPayload: Record<string, any>): CurrentUser {
+    return {
+      username: idTokenPayload["cognito:username"] ?? idTokenPayload.username,
+      sub: idTokenPayload.sub,
+      authTime: new Date(idTokenPayload.auth_time * 1000),
+      groups: idTokenPayload["cognito:groups"] ?? [],
+    };
+  }
+}

package/src/auth/static-token-auth.ts

@@ -0,0 +1,29 @@
+import { SystemInfoResponse } from "@cirrobio/api-client";
+import { AuthenticationProvider } from "./authentication-provider";
+import { CurrentUser } from "./current-user";
+
+
+export class StaticTokenAuthProvider implements AuthenticationProvider {
+  constructor(
+    readonly token: string
+  ) {
+  }
+
+  public configure(_ignore: SystemInfoResponse): void {
+    console.log('StaticTokenAuthProvider loaded');
+  }
+
+  public async getAccessToken() {
+    return this.token;
+  }
+
+  public async getCurrentUser() {
+    const accessToken = await this.getAccessToken();
+    const parsedToken = JSON.parse(atob(accessToken.split('.')[1]));
+    return CurrentUser.fromCognitoUser(parsedToken);
+  }
+
+  public forceRefresh(): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/src/auth.ts

@@ -0,0 +1,3 @@
+export type { AuthenticationProvider } from './auth/authentication-provider';
+export { StaticTokenAuthProvider } from './auth/static-token-auth';
+export { CurrentUser } from './auth/current-user';

package/src/data/data.service.ts

@@ -0,0 +1,128 @@
+import {
+  AuditApi,
+  BillingApi,
+  ComputeEnvironmentApi,
+  Configuration,
+  DatasetsApi,
+  ExecutionApi,
+  FileApi,
+  GovernanceApi,
+  MetadataApi,
+  NotebooksApi,
+  ProcessesApi,
+  ProjectRequestsApi,
+  ProjectsApi,
+  ReferencesApi,
+  SharingApi,
+  SystemApi,
+  ToolsApi,
+  UsersApi,
+  WorkspacesApi
+} from "@cirrobio/api-client";
+import { generateApiConfig } from "../api/config";
+
+interface DataServiceParams {
+  tokenGetter: () => Promise<string>;
+  basePath?: string;
+}
+
+export class DataService {
+  private readonly apiConfig: Configuration;
+
+  private readonly _auditApi: AuditApi;
+  private readonly _billingApi: BillingApi;
+  private readonly _computeEnvironmentApi: ComputeEnvironmentApi;
+  private readonly _datasetsApi: DatasetsApi;
+  private readonly _executionApi: ExecutionApi;
+  private readonly _fileApi: FileApi;
+  private readonly _governanceApi: GovernanceApi;
+  private readonly _metadataApi: MetadataApi;
+  private readonly _notebooksApi: NotebooksApi;
+  private readonly _processesApi: ProcessesApi;
+  private readonly _projectRequestsApi: ProjectRequestsApi;
+  private readonly _projectsApi: ProjectsApi;
+  private readonly _referencesApi: ReferencesApi;
+  private readonly _sharingApi: SharingApi;
+  private readonly _systemApi: SystemApi;
+  private readonly _toolsApi: ToolsApi;
+  private readonly _usersApi: UsersApi;
+  private readonly _workspacesApi: WorkspacesApi;
+
+  constructor({ tokenGetter, basePath = "/api" }: DataServiceParams) {
+    this.apiConfig = generateApiConfig({ basePath, tokenGetter });
+
+    this._auditApi = new AuditApi(this.apiConfig);
+    this._billingApi = new BillingApi(this.apiConfig);
+    this._computeEnvironmentApi = new ComputeEnvironmentApi(this.apiConfig);
+    this._datasetsApi = new DatasetsApi(this.apiConfig);
+    this._executionApi = new ExecutionApi(this.apiConfig);
+    this._fileApi = new FileApi(this.apiConfig);
+    this._governanceApi = new GovernanceApi(this.apiConfig);
+    this._metadataApi = new MetadataApi(this.apiConfig);
+    this._notebooksApi = new NotebooksApi(this.apiConfig);
+    this._processesApi = new ProcessesApi(this.apiConfig);
+    this._projectRequestsApi = new ProjectRequestsApi(this.apiConfig);
+    this._projectsApi = new ProjectsApi(this.apiConfig);
+    this._referencesApi = new ReferencesApi(this.apiConfig);
+    this._sharingApi = new SharingApi(this.apiConfig);
+    this._systemApi = new SystemApi(this.apiConfig);
+    this._toolsApi = new ToolsApi(this.apiConfig);
+    this._usersApi = new UsersApi(this.apiConfig);
+    this._workspacesApi = new WorkspacesApi(this.apiConfig);
+  }
+
+  get audit(): AuditApi {
+    return this._auditApi;
+  }
+  get billing(): BillingApi {
+    return this._billingApi;
+  }
+  get computeEnvironments(): ComputeEnvironmentApi {
+    return this._computeEnvironmentApi;
+  }
+  get datasets(): DatasetsApi {
+    return this._datasetsApi;
+  }
+  get execution(): ExecutionApi {
+    return this._executionApi;
+  }
+  get file(): FileApi {
+    return this._fileApi;
+  }
+  get governance(): GovernanceApi {
+    return this._governanceApi;
+  }
+  get metadata(): MetadataApi {
+    return this._metadataApi;
+  }
+  get notebooks(): NotebooksApi {
+    return this._notebooksApi;
+  }
+  get processes(): ProcessesApi {
+    return this._processesApi;
+  }
+  get projectRequests(): ProjectRequestsApi {
+    return this._projectRequestsApi;
+  }
+  get projects(): ProjectsApi {
+    return this._projectsApi;
+  }
+  get references(): ReferencesApi {
+    return this._referencesApi;
+  }
+  get sharing(): SharingApi {
+    return this._sharingApi;
+  }
+  get system(): SystemApi {
+    return this._systemApi;
+  }
+  get tools(): ToolsApi {
+    return this._toolsApi;
+  }
+  get users(): UsersApi {
+    return this._usersApi;
+  }
+  get workspaces(): WorkspacesApi {
+    return this._workspacesApi;
+  }
+}

package/src/data.ts

@@ -0,0 +1 @@
+export { DataService } from './data/data.service';

package/src/file/__test__/credentials-mutex.spec.ts

@@ -0,0 +1,44 @@
+import { Mutex } from "../util/credentials-mutex.so";
+
+describe('integration: credentialsMutex', () => {
+  const cache: Map<string, string> = new Map<string, string>();
+
+  beforeEach(() => {
+    cache.clear();
+  });
+
+  it('should only have one call with concurrent requests', async () => {
+    let fetchCount = 0;
+    const mutex = new Mutex();
+
+    const fetchCredentials = async (userId: string): Promise<string> => {
+      const cached = cache.get(userId);
+      if (cached) {
+        return cached;
+      }
+
+      fetchCount++;
+      // Simulate API call
+      await new Promise(resolve => setTimeout(resolve, 50));
+      const resp = userId;
+      cache.set(userId, resp);
+      return resp;
+    };
+
+    // Multiple concurrent requests for same user
+    const promises = [
+      mutex.dispatch(() => fetchCredentials('user1')),
+      mutex.dispatch(() => fetchCredentials('user1')),
+      mutex.dispatch(() => fetchCredentials('user1')),
+    ];
+
+    const results = await Promise.all(promises);
+
+    // Should return the same credentials
+    expect(results[0]).toEqual(results[1]);
+    expect(results[1]).toEqual(results[2]);
+
+    // But only one fetch should have occurred
+    expect(fetchCount).toBe(1);
+  });
+});

package/src/file/__test__/extensions.spec.ts

@@ -0,0 +1,36 @@
+import { FILE_IMAGE_EXTENSIONS, FILE_TXT_GENOMICS_EXTENSIONS, matchesExtension } from "../extensions.fn";
+
+describe("extensions", () => {
+  it("should return true when file extension matches", () => {
+    expect(matchesExtension("document.PDF", ["pdf"])).toBe(true);
+    expect(matchesExtension("image.jpg", FILE_IMAGE_EXTENSIONS)).toBe(true);
+    expect(matchesExtension("folder1/sample1.fastq", FILE_TXT_GENOMICS_EXTENSIONS)).toBe(true);
+    expect(matchesExtension("sample1.fastq.gz", FILE_TXT_GENOMICS_EXTENSIONS)).toBe(true);
+  });
+
+  it("should return false when file extension does not match", () => {
+    expect(matchesExtension("document.pdf", ["png"])).toBe(false);
+  });
+
+  it("should handle empty extensions array", () => {
+    expect(matchesExtension("file.txt", [])).toBe(false);
+  });
+
+  it("should handle files with multiple dots", () => {
+    expect(matchesExtension("my.file.name.txt", ["txt"])).toBe(true);
+  });
+
+  it("should handle files with no extension", () => {
+    expect(matchesExtension("README", ["txt"])).toBe(false);
+  });
+
+  it("should handle files with starting dot", () => {
+    expect(matchesExtension(".", [""])).toBe(true);
+    expect(matchesExtension(".gitignore", ["gitignore"])).toBe(true);
+    expect(matchesExtension(".bashrc", ["bashrc"])).toBe(true);
+  });
+
+  it("should handle empty string filename", () => {
+    expect(matchesExtension("", ["txt"])).toBe(false);
+  });
+});

package/src/file/__test__/manifest-parser.spec.ts

@@ -0,0 +1,67 @@
+import { DatasetAssetsManifest } from "@cirrobio/api-client";
+import { ManifestParser } from "../manifest-parser";
+import { FileSystemObjectType } from "../models/file-object.model";
+
+
+describe("manifestParser", () => {
+  const testManifest: DatasetAssetsManifest = {
+    domain: 's3://example-bucket/datasets',
+    files: [
+      {
+        path: 'file1.txt',
+        size: 1234,
+        metadata: {
+          description: 'Test file 1',
+        }
+      },
+      {
+        path: 'data/folder1/folder2/file2.txt',
+        size: 1234,
+        metadata: {
+        }
+      },
+      {
+        path: 'data/folder1/folder2/file3.txt',
+        size: 1234,
+        metadata: {
+        }
+      },
+    ],
+  }
+
+  it("should generate assets", () => {
+    const parser = new ManifestParser(testManifest);
+    const assets = parser.generateAssets();
+    expect(assets.length).toBe(3);
+    expect(assets[0].url).toBe('s3://example-bucket/datasets/file1.txt');
+    expect(assets[0].size).toBe(testManifest.files[0].size);
+    expect(assets[0].name).toBe('file1.txt');
+    expect(assets[0].path).toBe('');
+    expect(assets[0].displayPath).toBe('file1.txt');
+    expect(assets[0].id).toBeTruthy();
+    expect(assets[0].kind).toBe('txt');
+    expect(Object.keys(assets[0].metadata).length).toBe(1);
+    expect(assets[1].url).toBe('s3://example-bucket/datasets/data/folder1/folder2/file2.txt');
+    expect(assets[1].size).toBe(testManifest.files[0].size);
+    expect(assets[1].name).toBe('file2.txt');
+    expect(assets[1].path).toBe('data/folder1/folder2');
+    expect(assets[1].displayPath).toBe('folder1/folder2/file2.txt');
+    // calculate check
+    expect(assets.totalSizeBytes).toBe(3702);
+    expect(assets.totalSize).toBe("3.6 KiB");
+
+  });
+
+  it("should generate assets with folders", () => {
+    const parser = new ManifestParser(testManifest);
+    const assets = parser.generateAssets(true);
+    const folders = assets.filter(a => a.type === FileSystemObjectType.FOLDER);
+    expect(folders.length).toBe(3);
+    expect(folders[0].name).toBe('data');
+    expect(folders[1].name).toBe('folder1');
+    expect(folders[2].name).toBe('folder2');
+    expect(folders[2].displayPath).toBe('folder1/folder2');
+    const files = assets.filter(a => a.type === FileSystemObjectType.FILE);
+    expect(files.length).toBe(3);
+  });
+})

package/src/file/__test__/s3-utils.spec.ts

@@ -0,0 +1,17 @@
+import { s3UriToParams } from "../../file";
+
+
+describe("s3-utils", () => {
+  describe("s3UriToParams", () => {
+    it("should parse a valid s3 URI", () => {
+      const uri = "s3://my-bucket/my-key/nested/folder";
+      const result = s3UriToParams(uri);
+      expect(result).toEqual({ Bucket: "my-bucket", Key: "my-key/nested/folder" });
+    });
+
+    it("should throw an error for an invalid URI", () => {
+      const uri = "invalid-uri";
+      expect(() => s3UriToParams(uri)).toThrow(`Received invalid uri: '${uri}'`);
+    });
+  });
+})

package/src/file/__test__/utils.spec.ts

@@ -0,0 +1,9 @@
+import { getParentPath } from "../../file";
+
+describe('getParentPath', () => {
+  it('should return the parent path of a given file path', () => {
+    const filePath = 's3://bucket/path/to/file.txt';
+    const parentPath = getParentPath(filePath);
+    expect(parentPath).toBe('s3://bucket/path/to');
+  })
+})

package/src/file/actions/delete.fn.ts

@@ -0,0 +1,18 @@
+import { AWSCredentials } from "@cirrobio/api-client";
+import { DeleteObjectCommand } from "@aws-sdk/client-s3";
+import { s3UriToParams } from "../util/s3-utils";
+import { createS3Client } from "../util/s3-client";
+
+export interface DeleteFileParams {
+  url: string;
+  credentials: AWSCredentials;
+}
+
+/**
+ * Delete a file from S3 given its URL and credentials.
+ */
+export async function deleteFile({ url, credentials }: DeleteFileParams): Promise<void> {
+  const { Bucket, Key } = s3UriToParams(url);
+  const cmd = new DeleteObjectCommand({ Bucket, Key });
+  await createS3Client(credentials).send(cmd);
+}

package/src/file/actions/sign-url.fn.ts

@@ -0,0 +1,58 @@
+import { AWSCredentials } from "@cirrobio/api-client";
+import { GetObjectCommand, GetObjectCommandInput } from "@aws-sdk/client-s3";
+import { getSignedUrl as getSignedUrlInternal } from "@aws-sdk/s3-request-presigner";
+import { createS3Client } from "../util/s3-client";
+import { s3UriToParams } from "../util/s3-utils";
+import { S3ClientConfigType } from "@aws-sdk/client-s3/dist-types/S3Client";
+
+export interface GetFileUrlParams extends GetSignedUrlOptions {
+  url: string;
+  credentials?: AWSCredentials;
+}
+
+export interface GetSignedUrlOptions {
+  /**
+   * Whether to signal the browser to download this file on access
+   * (sets content disposition)
+   */
+  download?: boolean;
+  /**
+   * Whether to signal the browser to request gzipped content
+   */
+  gzip?: boolean;
+  /**
+   * Signed URL expiry timeout
+   * Defaults to 5 minutes
+   */
+  timeout?: number;
+  /**
+   * Override file name to download (when using download = true)
+   */
+  filename?: string;
+  /**
+   * Override the region of the bucket
+   */
+  region?: string;
+}
+
+/**
+ * Get a signed URL for a file in S3 given its S3 URI.
+ */
+export function getSignedUrl({ url, credentials, ...params }: GetFileUrlParams): Promise<string> {
+  const clientParams: S3ClientConfigType = {};
+  if (params.region) {
+    clientParams.region = params.region;
+  }
+  const client = createS3Client(credentials, clientParams);
+  const { Bucket, Key } = s3UriToParams(url);
+  const args: GetObjectCommandInput = { Bucket, Key };
+  if (params?.download) {
+    const fileName = params.filename ?? Key.split('/').pop();
+    args.ResponseContentDisposition = `attachment; filename="${fileName}"`
+  }
+  if (params?.gzip) {
+    args.ResponseContentEncoding = 'gzip'
+  }
+  const command = new GetObjectCommand(args);
+  return getSignedUrlInternal(client, command, { expiresIn: 60 * (params?.timeout ?? 5) });
+}

package/src/file/actions/upload.fn.ts

@@ -0,0 +1,33 @@
+import { Upload } from "@aws-sdk/lib-storage";
+import { AWSCredentials } from '@cirrobio/api-client';
+import { createS3Client } from "../util/s3-client";
+import { PutObjectCommandInput } from "@aws-sdk/client-s3";
+import { CreateMultipartUploadRequest } from "@aws-sdk/client-s3/dist-types/models/models_0";
+
+export interface UploadFileParams {
+  bucket: string;
+  path: string;
+  file: File;
+  credentials: AWSCredentials;
+  metadata?: Record<string, string>;
+}
+
+/**
+ * Upload a file to S3
+ */
+export function uploadFile({ bucket, path, file, credentials, metadata }: UploadFileParams): Upload {
+  const params: PutObjectCommandInput & CreateMultipartUploadRequest = {
+    Bucket: bucket,
+    Key: path,
+    Body: file,
+    ContentType: file.type,
+    Metadata: metadata,
+    ChecksumType: "FULL_OBJECT"
+  };
+  return new Upload({
+    client: createS3Client(credentials),
+    queueSize: 4,
+    params,
+  });
+}
+

package/src/file/calculate-size.ts

@@ -0,0 +1,14 @@
+import { FileSystemObject } from "./models/file-object.model";
+
+/**
+ * Calculate the total size of all files in a directory.
+ * @param files - An array of FileSystemObject representing the files in the directory.
+ * @return The total size of all files in bytes.
+ */
+export function calculateTotalSize(files: Array<FileSystemObject>): number {
+  let totalSize = 0;
+  for (const file of files) {
+    totalSize += file.size;
+  }
+  return totalSize;
+}

package/src/file/extensions.fn.ts

@@ -0,0 +1,88 @@
+
+/**
+ * An array of file extensions that can be rendered in a genome viewer
+ */
+export const FILE_TRACK_ANNOTATION = ['bed', 'bed.gz', 'gtf', 'gtf.gz'];
+export const FILE_TRACK_ALIGNMENTS = ['cram', 'cram.gz'];  // TODO: put back bam
+export const FILE_TRACK_VARIANT = ['vcf', 'vcf.gz'];
+export const FILE_TRACK_WIG = ['wig', 'wig.gz', 'bw', 'bw.gz', 'bigwig', 'bigwig.gz'];
+export const FILE_TRACK_SEG = ['seg', 'seg.gz'];
+export const FILE_TRACK_INDEX_EXTENSIONS = ['tbi', 'bai', 'crai', 'csi'];
+export const FILE_VITESSCE_EXTENSIONS = ['hdf5', 'h5ad', 'loom'];
+export const FILE_TRACK_EXTENSIONS_NO_INDEX = [
+    ...FILE_TRACK_ANNOTATION,
+    ...FILE_TRACK_ALIGNMENTS,
+    ...FILE_TRACK_VARIANT,
+    ...FILE_TRACK_WIG,
+    ...FILE_TRACK_SEG
+];
+export const FILE_TRACK_EXTENSIONS = [
+    ...FILE_TRACK_EXTENSIONS_NO_INDEX,
+    ...FILE_TRACK_INDEX_EXTENSIONS
+]
+
+
+export const FILE_BROWSER_EXTENSIONS = ['html', 'pdf'];
+
+
+/**
+ * An array of file extensions that are protein structure files.
+ */
+export const FILE_PROTEIN_STRUCTURE_EXTENSIONS = ['pdb', 'pdb.gz', 'cif', 'cif.gz', 'ent', 'ent.gz', 'mmtf', 'mmtf.gz'];
+/**
+ * An array of file extensions that are considered tabular files.
+ */
+export const FILE_DSV_EXTENSIONS = ['tab', 'csv', 'tsv', 'dsv'];
+/**
+ * An array of file extensions that contain genomic sequence content.
+ */
+export const FILE_TXT_GENOMICS_EXTENSIONS = ['fasta', 'fna', 'fsa', 'fa', 'fastp', 'fastq', 'faa', 'gbk', 'gff', 'vcf', 'seq'];
+
+/**
+ * An array of file extensions that are considered TXT files.
+ */
+export const FILE_TXT_EXTENSIONS = ['txt', 'log', 'yml', 'cfg', 'config', 'xml', 'yaml', ...FILE_DSV_EXTENSIONS, ...FILE_TXT_GENOMICS_EXTENSIONS];
+
+
+/**
+ * An array of file extensions that are considered image files.
+ */
+export const FILE_IMAGE_EXTENSIONS = ['jpg', 'jpeg', 'png', 'svg'];
+
+/**
+ * An array of file extensions that are considered OME (Open Microscopy Environment) files.
+ */
+export const FILE_OME_EXTENSIONS = ['tif', 'ome.tif', 'ome.tiff', 'ome.tif.gz', 'ome.tiff.gz'];
+
+/**
+ * An array of file extensions that can be opened in the browser.
+ * Includes common document formats such as HTML, PDF, and JSON, as well as image, DSV, TXT, and OME file formats.
+ */
+export const FILE_EXTENSIONS_TO_OPEN = ['html', 'pdf', 'json', 'fcs',
+    ...FILE_IMAGE_EXTENSIONS,
+    ...FILE_TXT_EXTENSIONS,
+    ...FILE_TRACK_EXTENSIONS,
+    ...FILE_PROTEIN_STRUCTURE_EXTENSIONS
+];
+
+
+/**
+ * Checks if a file has an extension that matches one in the provided list.
+ * @param filePath The file to check the extension of.
+ * @param extensions A list of file endings to check the file against.
+ * @returns True or false if the file has an ending in the extensions list.
+ */
+export function matchesExtension(filePath: string, extensions: string[]): boolean {
+    filePath = filePath.toLowerCase();
+
+    // Decompress the filePath if it ends with .gz
+    if (filePath.endsWith('.gz')) {
+        filePath = filePath.slice(0, -3);  // remove the .gz extension
+    }
+
+    // Now, get the extension of the file
+    const fileExtension = filePath.slice(filePath.lastIndexOf('.') + 1);
+
+    // Check if the fileExtension is in the list of extensions
+    return extensions.includes(fileExtension);
+}