Release 2.0.0 beta.2

apps/server/.mocharc.integration.json

@@ -0,0 +1,6 @@
+{
+	"extension": ["ts"],
+	"require": "ts-node/register",
+	"spec": "test/integration/**/*.spec.ts",
+	"timeout": 35000
+}

apps/server/.mocharc.json

@@ -2,5 +2,6 @@
 	"extension": ["ts"],
 	"require": "ts-node/register",
 	"spec": "test/**/*.spec.ts",
+	"ignore": ["test/integration/**/*"],
 	"timeout": 35000
 }

apps/server/package.json

@@ -1,13 +1,14 @@
 {
 	"name": "@overture-stack/lectern-server",
 	"private": true,
-	"version": "2.0.0-beta.1",
+	"version": "2.0.0-beta.2",
 	"description": "Overture Data Dictionary Management",
 	"scripts": {
 		"build": "tsc -p tsconfig.build.json",
 		"debug": "nodemon --watch 'src/**/*.ts' --ignore 'src/**/*.spec.ts' --exec node --inspect -r ts-node/register ./src/server.ts",
 		"start": "NODE_ENV=production ts-node -T src/server.ts",
-		"test": "nyc mocha"
+		"test": "nyc mocha",
+		"test:integration": "nyc mocha --config .mocharc.integration.json"
 	},
 	"repository": {
 		"type": "git",

package.json

@@ -1,19 +1,21 @@
 {
 	"name": "@overture-stack/lectern",
 	"private": true,
-	"version": "2.0.0-next.0",
+	"version": "2.0.0-beta.2",
 	"description": "Schema Manager and Validation for Data Dictionaries",
 	"scripts": {
 		"build:all": "pnpm nx run-many --all --target=build",
 		"build:dictionary": "pnpm nx build @overture-stack/lectern-dictionary",
 		"build:validation": "pnpm nx build @overture-stack/lectern-validation",
 		"build:server": "pnpm nx build @overture-stack/lectern-server",
 		"build:client": "pnpm nx build @overture-stack/lectern-client",
-		"test:all": "pnpm nx run-many --all --target=test",
-		"test:dictionary": "pnpm nx test @overture-stack/lectern-dictionary",
-		"test:validation": "pnpm nx test @overture-stack/lectern-validation",
-		"test:server": "pnpm nx test @overture-stack/lectern-server",
-		"test:client": "pnpm nx test @overture-stack/lectern-client",
+		"test:all": "pnpm nx run-many --all --target=test,test:integration",
+		"test:unit:all": "pnpm nx run-many --all --target=test",
+		"test:unit:dictionary": "pnpm nx test @overture-stack/lectern-dictionary",
+		"test:unit:validation": "pnpm nx test @overture-stack/lectern-validation",
+		"test:unit:server": "pnpm nx test @overture-stack/lectern-server",
+		"test:unit:client": "pnpm nx test @overture-stack/lectern-client",
+		"test:integration:server": "pnpm nx test:integration @overture-stack/lectern-server",
 		"generate": "pnpm build:dictionary && pnpm -C scripts generate"
 	},
 	"keywords": [],

packages/client/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@overture-stack/lectern-client",
-	"version": "2.0.0-beta.1",
+	"version": "2.0.0-beta.2",
 	"files": [
 		"dist/"
 	],

packages/client/src/index.ts

@@ -36,15 +36,19 @@ export type {
 	TestResult,
 	TestResultValid,
 	TestResultInvalid,
+	SchemaValidationRecordErrorDetails,
 	SchemaRecordError,
+	DictionaryValidationRecordErrorDetails,
 	DictionaryValidationError,
+	FieldValidationErrorRestrictionInfo,
 	FieldValidationError,
 	ParseDictionaryData,
 	ParseDictionaryFailure,
 	ParseDictionaryResult,
 	ParseSchemaError,
 	ParseSchemaFailureData,
 	ParseSchemaResult,
+	ParseRecordFailureData,
 	ParseRecordResult,
 } from '@overture-stack/lectern-validation';
 

packages/dictionary/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@overture-stack/lectern-dictionary",
-	"version": "2.0.0-beta.1",
+	"version": "2.0.0-beta.2",
 	"description": "",
 	"files": [
 		"dist/"

packages/dictionary/src/metaSchema/dictionarySchemas.ts

@@ -181,6 +181,7 @@ export const SchemaFieldBase = zod
 	.object({
 		name: NameValue,
 		description: zod.string().optional(),
+		delimiter: zod.string().min(1).optional(),
 		isArray: zod.boolean().optional(),
 		meta: DictionaryMeta.optional(),
 		unique: zod.boolean().optional(),

packages/dictionary/test/metaSchema/dictionarySchemas.spec.ts

@@ -151,6 +151,44 @@ describe('Dictionary Schemas', () => {
 			};
 			expect(SchemaField.safeParse(fieldBoolean).success, 'Boolean field invalid.').true;
 		});
+		describe('Delimiter', () => {
+			it('Field can have delimiter', () => {
+				const field: SchemaField = {
+					name: 'some-name',
+					valueType: 'string',
+					isArray: true,
+					delimiter: '|',
+				};
+				expect(SchemaField.safeParse(field).success).true;
+			});
+			it('Delimiter values must have minimum length 1', () => {
+				const field: SchemaField = {
+					name: 'some-name',
+					valueType: 'string',
+					isArray: true,
+					delimiter: '',
+				};
+				expect(SchemaField.safeParse(field).success).false;
+			});
+			it('Delimiter value can have multiple characters', () => {
+				const field: SchemaField = {
+					name: 'some-name',
+					valueType: 'string',
+					isArray: true,
+					delimiter: '-/-',
+				};
+				expect(SchemaField.safeParse(field).success).true;
+			});
+			it('Delimiter value can be whitespace', () => {
+				const field: SchemaField = {
+					name: 'some-name',
+					valueType: 'string',
+					isArray: true,
+					delimiter: '   ',
+				};
+				expect(SchemaField.safeParse(field).success).true;
+			});
+		});
 	});
 	describe('Schema', () => {
 		it("Can't have repeated field names", () => {

packages/validation/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@overture-stack/lectern-validation",
-	"version": "2.0.0-beta.1",
+	"version": "2.0.0-beta.2",
 	"description": "Logic for validating data using a Lectern dictionary",
 	"files": [
 		"dist/"

packages/validation/src/parseValues/parseValues.ts

@@ -138,7 +138,7 @@ const convertArrayValue = (value: string, fieldDefinition: SchemaField): Result<
 
 	/* === Start of convertArrayValue logic === */
 	const { valueType } = fieldDefinition;
-	const delimiter = DEFAULT_DELIMITER;
+	const delimiter = fieldDefinition.delimiter !== undefined ? fieldDefinition.delimiter : DEFAULT_DELIMITER;
 
 	const normalizedValue = normalizeValue(value);
 	if (normalizedValue === '') {

packages/validation/test/parseValues/parseField.spec.ts

@@ -300,5 +300,34 @@ describe('Parse Values - parseFieldValue', () => {
 			it('Boolean array field, rejects array where value is missing (two delimiters are adjacent)');
 			expect(parseFieldValue(',true,false,TRUE', fieldBooleanArrayRequired).success).false;
 		});
+		describe('Custom delimiter', () => {
+			it('Uses a `,` as the delimiter when none is defined', () => {
+				const result = parseFieldValue(':,_,|,/', fieldStringArrayRequired);
+				expect(result.success).true;
+				expect(result.data).deep.equal([':', '_', '|', '/']);
+			});
+			it('Splits array on the delimiter when defined', () => {
+				const customDelimiterField = { ...fieldStringArrayRequired, delimiter: '|' };
+				const result = parseFieldValue(':,_,|,/', customDelimiterField);
+				expect(result.success).true;
+				expect(result.data).deep.equal([':,_,', ',/']);
+
+				const result2 = parseFieldValue('abc|def|ghi', customDelimiterField);
+				expect(result2.success).true;
+				expect(result2.data).deep.equal(['abc', 'def', 'ghi']);
+			});
+			it('Splits arrays with delimiters with more than 1 character', () => {
+				const customDelimiterField = { ...fieldStringArrayRequired, delimiter: '-/-' };
+				const result = parseFieldValue('a-/-b-/-c-/-d', customDelimiterField);
+				expect(result.success).true;
+				expect(result.data).deep.equal(['a', 'b', 'c', 'd']);
+			});
+			it('Splits arrays with delimiters that are entirely whitespace', () => {
+				const customDelimiterField = { ...fieldStringArrayRequired, delimiter: '   ' };
+				const result = parseFieldValue('a   b   c   d', customDelimiterField);
+				expect(result.success).true;
+				expect(result.data).deep.equal(['a', 'b', 'c', 'd']);
+			});
+		});
 	});
 });