@opencloning/utils 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @opencloning/utils
 
+## 1.3.0
+
+### Minor Changes
+
+- [#597](https://github.com/manulera/OpenCloning_frontend/pull/597) [`d5a456d`](https://github.com/manulera/OpenCloning_frontend/commit/d5a456d70ccfe949b21aae260d2c99507ff6a88e) Thanks [@manulera](https://github.com/manulera)! - Changes associated with new "Syntax Builder" application for creating and managing modular cloning syntaxes, along with significant refactoring of assembler components to support both the new app and the existing OpenCloning application.
+
+  - Added a new standalone app (`apps/syntax-builder`) for building and editing cloning syntaxes with visual previews
+  - Refactored assembler components to be more modular and reusable across applications
+  - Enhanced file parsing utilities to support bidirectional conversion between JSON and delimited formats
+  - Added graph-based validation and visualization for syntax parts using the graphology library
+
+### Patch Changes
+
+- Updated dependencies [[`d5a456d`](https://github.com/manulera/OpenCloning_frontend/commit/d5a456d70ccfe949b21aae260d2c99507ff6a88e)]:
+  - @opencloning/store@1.3.0
+
 ## 1.2.0
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencloning/utils",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "main": "./src/utils/index.js",
   "exports": {
@@ -27,7 +27,7 @@
     "directory": "packages/utils"
   },
   "dependencies": {
-    "@opencloning/store": "1.2.0",
+    "@opencloning/store": "1.3.0",
     "@teselagen/bio-parsers": "^0.4.32",
     "@teselagen/sequence-utils": "^0.3.35",
     "@zip.js/zip.js": "^2.7.62",

package/src/config/urlWhitelist.js

@@ -1,3 +1,5 @@
+/* istanbul ignore file */
+
 export default [
   // GitHub repository for OpenCloning templates
   'https://assets.opencloning.org/OpenCloning-submission',
@@ -9,6 +11,8 @@ export default [
   'https://assets.opencloning.org/SnapGene_crawler',
   // GitHub repository for Open DNA Collections index
   'https://assets.opencloning.org/open-dna-collections',
+  // GitHub repository for syntaxes
+  'https://assets.opencloning.org/syntaxes/syntaxes',
   // NCBI entrez API
   'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi',
   'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi',

package/src/utils/fileParsers.js

@@ -1,7 +1,8 @@
 import { stringIsNotDNA } from '@opencloning/store/cloning_utils';
 import { readSubmittedTextFile } from './readNwrite';
 
-export const primersFromTextFile = async (fileUploaded, existingNames) => {
+export async function delimitedFileToJson(fileUploaded, requiredHeaders = []) {
+
   const fileContent = await readSubmittedTextFile(fileUploaded);
   const allLines = fileContent.split(/\r\n|\r|\n/);
 
@@ -27,43 +28,36 @@ export const primersFromTextFile = async (fileUploaded, existingNames) => {
 
   const headers = lines[0].split(delimiter);
 
-  const requiredHeaders = ['name', 'sequence'];
   const missingHeaders = requiredHeaders.filter(
     (header) => !headers.includes(header),
   );
 
-  // The number of tabs on headers and all lines should be > 1 and the same
-  if (headers.length < 2) {
-    throw new Error('Headers should have at least 2 columns');
+  if (missingHeaders.length > 0) {
+    throw new Error(`Headers missing: ${missingHeaders.join(', ')}`);
   }
 
   // All lines should have the same number of tabs
   if (lines.some((line) => line.split(delimiter).length !== headers.length)) {
     throw new Error('All lines should have the same number of columns');
   }
-
-  // Required headers should be present
-  if (missingHeaders.length > 0) {
-    throw new Error(`Headers missing: ${missingHeaders.join(', ')}`);
-  }
-
-  const primersToAdd = lines.slice(1).map((line) => {
+  return lines.slice(1).map((line) => {
     const values = line.split(delimiter);
-    const obj = { error: '' };
+    const obj = {};
     headers.forEach((header, i) => {
       obj[header] = values[i];
     });
-
-    if (existingNames.includes(obj.name)) {
-      obj.error = 'existing';
-    } else if (stringIsNotDNA(obj.sequence)) {
-      obj.error = 'invalid';
-      // TODO: Improvement: check for already existing sequences
-      // While this is not a problem, it removes data redundancy
-    }
-
     return obj;
   });
+};
 
-  return primersToAdd;
+export const primersFromTextFile = async (fileUploaded, existingNames) => {
+  const primers = await delimitedFileToJson(fileUploaded, ['name', 'sequence']);
+  return primers.map((primer) => {
+    if (existingNames.includes(primer.name)) {
+      return { ...primer, error: 'existing' };
+    } else if (stringIsNotDNA(primer.sequence)) {
+      return { ...primer, error: 'invalid' };
+    }
+    return { ...primer, error: '' };
+  });
 };

package/src/utils/fileParsers.test.js

@@ -0,0 +1,241 @@
+import { describe, it, expect } from 'vitest';
+import { delimitedFileToJson, primersFromTextFile } from './fileParsers';
+
+// Helper function to create a File object for testing
+// File is a browser global available in jsdom test environment
+function createFile(content, filename) {
+  // eslint-disable-next-line no-undef
+  return new File([content], filename, { type: 'text/plain' });
+}
+
+describe('delimitedFileToJson', () => {
+  it('parses CSV file with comma delimiter', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC\nprimer2,CGTG', 'test.csv');
+
+    const result = await delimitedFileToJson(file);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG' }
+    ]);
+  });
+
+  it('parses CSV file with semicolon delimiter', async () => {
+    const file = createFile('name;sequence\nprimer1;ATGC\nprimer2;CGTG', 'test.csv');
+
+    const result = await delimitedFileToJson(file);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG' }
+    ]);
+  });
+
+  it('parses TSV file with tab delimiter', async () => {
+    const file = createFile('name\tsequence\nprimer1\tATGC\nprimer2\tCGTG', 'test.tsv');
+
+    const result = await delimitedFileToJson(file);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG' }
+    ]);
+  });
+
+  it('throws error for non-CSV/TSV file', async () => {
+    const file = createFile('some content', 'test.txt');
+
+    await expect(delimitedFileToJson(file)).rejects.toThrow('File must be a .csv or .tsv file');
+  });
+
+  it('throws error when CSV contains both comma and semicolon', async () => {
+    const file = createFile('name,sequence;other\nprimer1,ATGC;extra', 'test.csv');
+
+    await expect(delimitedFileToJson(file)).rejects.toThrow('File must contain only one delimiter, either comma or semicolon');
+  });
+
+  it('throws error for empty file', async () => {
+    const file = createFile('', 'test.csv');
+
+    await expect(delimitedFileToJson(file)).rejects.toThrow('File is empty');
+  });
+
+  it('throws error for file with only empty lines', async () => {
+    const file = createFile('\n\n  \n\r\n', 'test.csv');
+
+    await expect(delimitedFileToJson(file)).rejects.toThrow('File is empty');
+  });
+
+  it('removes empty lines', async () => {
+    const file = createFile('name,sequence\n\nprimer1,ATGC\n  \nprimer2,CGTG', 'test.csv');
+
+    const result = await delimitedFileToJson(file);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG' }
+    ]);
+  });
+
+  it('validates required headers', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC', 'test.csv');
+
+    await expect(delimitedFileToJson(file, ['name', 'sequence', 'required'])).rejects.toThrow('Headers missing: required');
+
+    const file2 = createFile('name,sequence\nprimer1,ATGC', 'test.csv');
+
+    const result = await delimitedFileToJson(file2, ['name', 'sequence']);
+
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' }
+    ]);
+  });
+
+  it('validates multiple missing headers', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC', 'test.csv');
+
+    await expect(delimitedFileToJson(file, ['name', 'required1', 'required2'])).rejects.toThrow('Headers missing: required1, required2');
+  });
+
+  it('throws error when rows have inconsistent column count', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC,extra\nprimer2,CGTG', 'test.csv');
+
+    await expect(delimitedFileToJson(file)).rejects.toThrow('All lines should have the same number of columns');
+  });
+
+  it('handles Windows line endings (\\r\\n)', async () => {
+    const file = createFile('name,sequence\r\nprimer1,ATGC\r\nprimer2,CGTG', 'test.csv');
+
+    const result = await delimitedFileToJson(file);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG' }
+    ]);
+  });
+
+  it('handles Mac line endings (\\r)', async () => {
+    const file = createFile('name,sequence\rprimer1,ATGC\rprimer2,CGTG', 'test.csv');
+
+    const result = await delimitedFileToJson(file);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG' }
+    ]);
+  });
+
+  it('handles Unix line endings (\\n)', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC\nprimer2,CGTG', 'test.csv');
+
+    const result = await delimitedFileToJson(file);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG' }
+    ]);
+  });
+
+  it('handles empty required headers array', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC', 'test.csv');
+
+    const result = await delimitedFileToJson(file, []);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' }
+    ]);
+  });
+
+  it('handles single row data', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC', 'test.csv');
+
+    const result = await delimitedFileToJson(file);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC' }
+    ]);
+  });
+});
+
+describe('primersFromTextFile', () => {
+  it('parses valid primers without errors', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC\nprimer2,CGTG', 'test.csv');
+
+    const result = await primersFromTextFile(file, []);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC', error: '' },
+      { name: 'primer2', sequence: 'CGTG', error: '' }
+    ]);
+  });
+
+  it('marks primers with existing names', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC\nprimer2,CGTG', 'test.csv');
+
+    const result = await primersFromTextFile(file, ['primer1']);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC', error: 'existing' },
+      { name: 'primer2', sequence: 'CGTG', error: '' }
+    ]);
+  });
+
+  it('marks primers with invalid DNA sequences', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC\nprimer2,XYZ', 'test.csv');
+
+    const result = await primersFromTextFile(file, []);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC', error: '' },
+      { name: 'primer2', sequence: 'XYZ', error: 'invalid' }
+    ]);
+  });
+
+  it('prioritizes existing name error over invalid sequence error', async () => {
+    const file = createFile('name,sequence\nprimer1,XYZ', 'test.csv');
+
+    const result = await primersFromTextFile(file, ['primer1']);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'XYZ', error: 'existing' }
+    ]);
+  });
+
+  it('handles multiple primers with mixed errors', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC\nprimer2,XYZ\nprimer3,CGTG', 'test.csv');
+
+    const result = await primersFromTextFile(file, ['primer1']);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC', error: 'existing' },
+      { name: 'primer2', sequence: 'XYZ', error: 'invalid' },
+      { name: 'primer3', sequence: 'CGTG', error: '' }
+    ]);
+  });
+
+  it('requires name and sequence headers', async () => {
+    const file = createFile('name,other\nprimer1,ATGC', 'test.csv');
+
+    await expect(primersFromTextFile(file, [])).rejects.toThrow('Headers missing: sequence');
+  });
+
+  it('handles empty existing names array', async () => {
+    const file = createFile('name,sequence\nprimer1,ATGC', 'test.csv');
+
+    const result = await primersFromTextFile(file, []);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC', error: '' }
+    ]);
+  });
+
+  it('handles TSV format', async () => {
+    const file = createFile('name\tsequence\nprimer1\tATGC', 'test.tsv');
+
+    const result = await primersFromTextFile(file, []);
+    
+    expect(result).toEqual([
+      { name: 'primer1', sequence: 'ATGC', error: '' }
+    ]);
+  });
+});

package/src/utils/getHttpClient.js

@@ -2,7 +2,11 @@ import axios from 'axios';
 import urlWhitelist from '../config/urlWhitelist';
 
 export default function getHttpClient(extraUrls = []) {
-  const whitelist = [...urlWhitelist, import.meta.env.BASE_URL, window.location.origin, ...extraUrls];
+  const baseURL = import.meta.env.BASE_URL || null;
+  const whitelist = [...urlWhitelist, window.location.origin, ...extraUrls];
+  if (baseURL) {
+    whitelist.push(baseURL);
+  }
 
   const client = axios.create();
 

package/src/utils/readNwrite.js

@@ -293,3 +293,15 @@ export function updateVerificationFileNames(verificationFiles, originalFiles, va
     return file;
   });
 }
+
+export function jsonToDelimitedFile(json, delimiter = '\t') {
+  const headers = Object.keys(json[0]);
+  const rows = json.map((obj) =>
+    headers
+      .map((header) =>
+        String(obj[header]).replaceAll(/[\r\n]+/g, ' ').replaceAll(delimiter, ' ')
+      )
+      .join(delimiter)
+  );
+  return [headers.join(delimiter), ...rows].join('\n');
+}

package/src/utils/readNwrite.test.js

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest';
+import { jsonToDelimitedFile } from './readNwrite';
+
+describe('jsonToDelimitedFile', () => {
+  it('converts JSON array to delimited file with default tab delimiter', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC', length: 4 },
+      { name: 'primer2', sequence: 'CGTG', length: 4 }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\tlength\nprimer1\tATGC\t4\nprimer2\tCGTG\t4');
+  });
+
+  it('converts JSON array to CSV with comma delimiter', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG' }
+    ];
+
+    const result = jsonToDelimitedFile(json, ',');
+
+    expect(result).toBe('name,sequence\nprimer1,ATGC\nprimer2,CGTG');
+  });
+
+  it('handles single row', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC' }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\nprimer1\tATGC');
+  });
+
+  it('handles empty string values', () => {
+    const json = [
+      { name: 'primer1', sequence: '', length: 4 },
+      { name: '', sequence: 'ATGC', length: 4 }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\tlength\nprimer1\t\t4\n\tATGC\t4');
+  });
+
+  it('handles null and undefined values', () => {
+    const json = [
+      { name: 'primer1', sequence: null, length: undefined },
+      { name: null, sequence: 'ATGC', length: 4 }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\tlength\nprimer1\tnull\tundefined\nnull\tATGC\t4');
+  });
+
+  it('handles numeric values', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC', length: 4, temperature: 65.5 },
+      { name: 'primer2', sequence: 'CGTG', length: 4, temperature: 67.0 }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\tlength\ttemperature\nprimer1\tATGC\t4\t65.5\nprimer2\tCGTG\t4\t67');
+  });
+
+  it('handles boolean values', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC', active: true },
+      { name: 'primer2', sequence: 'CGTG', active: false }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\tactive\nprimer1\tATGC\ttrue\nprimer2\tCGTG\tfalse');
+  });
+
+  it('handles values containing delimiter characters', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC', description: 'test\twith\ttabs' },
+      { name: 'primer2', sequence: 'CGTG', description: 'test,with,commas' }
+    ];
+
+    const result = jsonToDelimitedFile(json, '\t');
+
+    expect(result).toBe('name\tsequence\tdescription\nprimer1\tATGC\ttest with tabs\nprimer2\tCGTG\ttest,with,commas');
+  });
+
+  it('handles values containing newlines', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC', notes: 'line1\nline2' },
+      { name: 'primer2', sequence: 'CGTG', notes: 'single line' }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\tnotes\nprimer1\tATGC\tline1 line2\nprimer2\tCGTG\tsingle line');
+  });
+
+  it('preserves order of headers based on first object', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC', length: 4 },
+      { length: 4, sequence: 'CGTG', name: 'primer2' }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\tlength\nprimer1\tATGC\t4\nprimer2\tCGTG\t4');
+  });
+
+  it('handles objects with different keys by using first object keys', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG', extra: 'field' }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\nprimer1\tATGC\nprimer2\tCGTG');
+  });
+
+  it('handles missing values in subsequent objects', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC', length: 4 },
+      { name: 'primer2', sequence: 'CGTG' }
+    ];
+
+    const result = jsonToDelimitedFile(json);
+
+    expect(result).toBe('name\tsequence\tlength\nprimer1\tATGC\t4\nprimer2\tCGTG\tundefined');
+  });
+
+  it('handles custom delimiter with multiple characters', () => {
+    const json = [
+      { name: 'primer1', sequence: 'ATGC' },
+      { name: 'primer2', sequence: 'CGTG' }
+    ];
+
+    const result = jsonToDelimitedFile(json, ' | ');
+
+    expect(result).toBe('name | sequence\nprimer1 | ATGC\nprimer2 | CGTG');
+  });
+});