typeomatica 0.2.7 → 0.2.9

package/.github/workflows/node.js.yml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [12.x, 14.x]
+        node-version: [14.x, 16.x, 18.x]
 
     steps:
     - uses: actions/checkout@v2
@@ -34,10 +34,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@master
-    - name: Use Node.js 12.x
+    - name: Use Node.js 14.x
       uses: actions/setup-node@master
       with:
-        node-version: 12.x
+        node-version: 14.x
 
     - name: npm install
       run: npm install

package/jest.config.js

@@ -2,9 +2,7 @@ module.exports = {
 	preset: 'ts-jest',
 	testEnvironment: 'node',
 	testMatch: ['**/test/**/index.ts', '**/test/**/addition.js'],
-	globals: {
-		'ts-jest': {
-			tsconfig: './test/tsconfig.json'
-		}
-	},
+	transform       : {
+		'\\./test/*.ts$': ['ts-jest', { tsconfig : './tsconfig.jest.json' }]
+	}
 };

package/lib/errors.d.ts

@@ -3,4 +3,5 @@ export declare const ErrorsNames: {
     ACCESS_DENIED: string;
     MISSING_PROP: string;
     RIP_FUNCTIONS: string;
+    FORBIDDEN_RE: string;
 };

package/lib/errors.js

@@ -5,5 +5,6 @@ exports.ErrorsNames = {
     TYPE_MISMATCH: 'Type Mismatch',
     ACCESS_DENIED: 'Value Access Denied',
     MISSING_PROP: 'Attempt to Access to Undefined Prop',
-    RIP_FUNCTIONS: 'Functions are Restricted'
+    RIP_FUNCTIONS: 'Functions are Restricted',
+    FORBIDDEN_RE: 'Re-Assirnment is Forbidden'
 };

package/lib/fields.d.ts

@@ -1,2 +1,11 @@
 export declare const SymbolInitialValue: unique symbol;
-export declare const FieldConstructor: ObjectConstructor;
+interface FieldDefinition {
+    [SymbolInitialValue]: unknown;
+}
+export declare class FieldConstructor implements FieldDefinition {
+    [SymbolInitialValue]: unknown;
+    get get(): (this: FieldDefinition) => unknown;
+    get set(): () => never;
+    constructor(value: unknown);
+}
+export {};

package/lib/fields.js

@@ -2,8 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldConstructor = exports.SymbolInitialValue = void 0;
 exports.SymbolInitialValue = Symbol('Initial Value');
-exports.FieldConstructor = function (value) {
-    this[exports.SymbolInitialValue] = value;
-};
-Object.freeze(exports.FieldConstructor.prototype);
-Object.seal(exports.FieldConstructor.prototype);
+const errors_1 = require("./errors");
+class FieldConstructor {
+    constructor(value) {
+        this[exports.SymbolInitialValue] = value;
+    }
+    get get() {
+        const self = this;
+        return function () {
+            return self[exports.SymbolInitialValue];
+        };
+    }
+    get set() {
+        return function () {
+            throw new TypeError(errors_1.ErrorsNames.FORBIDDEN_RE);
+        };
+    }
+}
+exports.FieldConstructor = FieldConstructor;
+Object.freeze(FieldConstructor.prototype);
+Object.seal(FieldConstructor.prototype);

package/lib/index.js

@@ -42,11 +42,18 @@ const createProperty = (propName, initialValue, receiver) => {
     const descriptor = (isObject && (value instanceof fields_1.FieldConstructor)) ?
         value
         : Object.assign({ enumerable: true }, resolver[type](value, receiver));
-    const result = Reflect.defineProperty(receiver, propName, descriptor);
-    return result;
+    try {
+        const result = Reflect.defineProperty(receiver, propName, descriptor);
+        return result;
+    }
+    catch (error) {
+        throw error;
+    }
 };
+const props2skip = new Set([Symbol.toStringTag, Symbol.iterator]);
 const util = require('util');
-const props2skip = new Set([util.inspect.custom, Symbol.toStringTag, Symbol.iterator]);
+const hasNodeInspect = (util && util.inspect && util.inspect.custom);
+hasNodeInspect && (props2skip.add(util.inspect.custom));
 const handlers = {
     get(target, prop, receiver) {
         const result = Reflect.get(target, prop, receiver);

package/package.json

@@ -1,7 +1,10 @@
 {
 	"name": "typeomatica",
-	"version": "0.2.7",
+	"version": "0.2.9",
 	"description": "type logic against javascript metaprogramming",
+	"engines": {
+		"node": ">=14"
+	},
 	"main": "lib/index.js",
 	"scripts": {
 		"build": "rm -rf ./lib && npx tsc --pretty",
@@ -27,16 +30,16 @@
 		"url": "git+https://github.com/wentout/typeomatica.git"
 	},
 	"devDependencies": {
-		"@types/jest": "^27.0.1",
-		"@types/node": "^16.9.2",
-		"eslint": "^7.32.0",
-		"husky": "^8.0.0",
-		"jest": "^27.2.0",
-		"lint-staged": "^11.1.2",
+		"@types/jest": "^29.2.5",
+		"@types/node": "^18.11.18",
+		"eslint": "^8.31.0",
+		"husky": "^8.0.3",
+		"jest": "^29.3.1",
+		"json5": "^2.2.3",
+		"lint-staged": "^13.1.0",
 		"set-value": "^4.1.0",
-		"ts-jest": "^27.0.5",
-		"ts-node": "^10.2.1",
-		"tslint": "^6.1.3",
-		"typescript": "^4.4.3"
+		"ts-jest": "^29.0.3",
+		"ts-node": "^10.9.1",
+		"typescript": "^4.9.4"
 	}
 }

package/src/errors.ts

@@ -4,5 +4,6 @@ export const ErrorsNames = {
 	TYPE_MISMATCH: 'Type Mismatch',
 	ACCESS_DENIED: 'Value Access Denied',
 	MISSING_PROP: 'Attempt to Access to Undefined Prop',
-	RIP_FUNCTIONS: 'Functions are Restricted'
+	RIP_FUNCTIONS: 'Functions are Restricted',
+	FORBIDDEN_RE: 'Re-Assirnment is Forbidden'
 };

package/src/fields.ts

@@ -2,6 +2,8 @@
 
 export const SymbolInitialValue = Symbol('Initial Value');
 
+import { ErrorsNames } from './errors'
+
 interface FieldDefinition  {
 	[SymbolInitialValue]: unknown
 	// get?: unknown
@@ -11,9 +13,27 @@ interface FieldDefinition  {
 	// writable: boolean
 }
 
-export const FieldConstructor = function (this: FieldDefinition, value: unknown) {
-	this[SymbolInitialValue] = value;
-} as ObjectConstructor;
+// export const FieldConstructor = function (this: FieldDefinition, value: unknown) {
+// 	this[SymbolInitialValue] = value;
+// } as ObjectConstructor;
+
+export class FieldConstructor implements FieldDefinition {
+	[SymbolInitialValue]: unknown
+	public get get () {
+		const self = this;
+		return function (this: FieldDefinition) {
+			return self[SymbolInitialValue];
+		}
+	}
+	public get set () {
+		return function () {
+			throw new TypeError(ErrorsNames.FORBIDDEN_RE);
+		}
+	}
+	constructor (value: unknown) {
+		this[SymbolInitialValue] = value;
+	}
+}
 
 // Object.assign(FieldConstructor.prototype, {
 // 	configurable: false,

package/src/index.ts

@@ -44,7 +44,6 @@ const resolver = Object.entries({
 	return obj;
 }, {});
 
-
 const createProperty = (propName: string, initialValue: unknown, receiver: object) => {
 
 	const value = initialValue;
@@ -80,13 +79,20 @@ const createProperty = (propName: string, initialValue: unknown, receiver: objec
 	// 	debugger;
 	// }
 
-	const result = Reflect.defineProperty(receiver, propName, descriptor);
-	return result;
+	try {
+		const result = Reflect.defineProperty(receiver, propName, descriptor);
+		return result;
+	} catch (error) {
+		// debugger;
+		throw error;
+	}
 
 };
 
+const props2skip = new Set([Symbol.toStringTag, Symbol.iterator]);
 const util = require('util');
-const props2skip = new Set([util.inspect.custom, Symbol.toStringTag, Symbol.iterator]);
+const hasNodeInspect = (util && util.inspect && util.inspect.custom);
+hasNodeInspect && (props2skip.add(util.inspect.custom));
 
 const handlers = {
 	get(target: object, prop: string | symbol, receiver: object) {
@@ -103,6 +109,7 @@ const handlers = {
 				}, {}));
 			}
 		}
+		// @ts-ignore
 		if (props2skip.has(prop)) {
 			return undefined;
 		}

package/test/__snapshots__/index.ts.snap

@@ -1,3 +1,3 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`props tests correct JSON.stringify 1`] = `"\\"{\\\\\\"numberValue\\\\\\":123,\\\\\\"stringValue\\\\\\":\\\\\\"123\\\\\\",\\\\\\"booleanValue\\\\\\":false,\\\\\\"objectValue\\\\\\":{}}\\""`;
+exports[`props tests correct JSON.stringify 1`] = `""{\\"numberValue\\":123,\\"stringValue\\":\\"123\\",\\"booleanValue\\":false,\\"objectValue\\":{}}""`;

package/test/index.ts

@@ -1,5 +1,7 @@
 'use strict';
 
+import { describe, expect, test } from '@jest/globals';
+
 // BasePrototype & BaseClass are the same function
 // go as you want for being meaningfull
 // or meaningless
@@ -8,8 +10,6 @@ const BasePrototype = require('..');
 // @ts-ignore
 import { BaseClass, IDEF, FieldConstructor } from '..';
 
-debugger;
-
 class Base extends BasePrototype({
 	additionalProp: 321,
 	someMethod() {
@@ -72,23 +72,61 @@ const extendedSetInstance = new ExtendedSet;
 const MUTATION_VALUE = -2;
 
 
-class MyFieldConstructor extends FieldConstructor {
+class MyFieldConstructorNoRe extends FieldConstructor {
+	_value: string
+	constructor(value: string) {
+		super(value);
+		Reflect.defineProperty(this, 'enumerable', {
+			value: true
+		});
+		this._value = value;
+	}
+}
+class MyFieldConstructorReGet extends MyFieldConstructorNoRe {
 	constructor(value: string) {
 		super(value);
+		const self = this;
 		Reflect.defineProperty(this, 'enumerable', {
 			value: true
 		});
 		Reflect.defineProperty(this, 'get', {
-			get () {
+			get() {
 				return function () {
-					return value;
+					return self._value;
 				}
-			}
+			},
+			enumerable: true
+		});
+	}
+}
+class MyFieldConstructorReSet extends MyFieldConstructorNoRe {
+	constructor(value: string) {
+		super(value);
+		const self = this;
+		Reflect.defineProperty(this, 'enumerable', {
+			value: true
 		});
 		Reflect.defineProperty(this, 'set', {
-			get () {
-				return function (_value: string) {
-					value = _value;
+			get() {
+				return function (value: string) {
+					self._value = value;
+				}
+			},
+			enumerable: true
+		});
+	}
+}
+class MyFieldConstructor extends MyFieldConstructorReGet {
+	constructor(value: string) {
+		super(value);
+		const self = this;
+		Reflect.defineProperty(this, 'enumerable', {
+			value: true
+		});
+		Reflect.defineProperty(this, 'set', {
+			get() {
+				return function (value: string) {
+					self._value = value;
 				}
 			},
 			enumerable: true
@@ -96,13 +134,21 @@ class MyFieldConstructor extends FieldConstructor {
 	}
 }
 
-const myField = new MyFieldConstructor('zzz');
-class MadeFieldClass extends BaseClass { myField = myField };
-class SecondMadeFieldClass extends BaseClass { myField = myField };
+const myField = new MyFieldConstructor('initial value');
+const myFieldReGet = new MyFieldConstructorReGet('initial value for get check');
+const myFieldReSet = new MyFieldConstructorReSet('initial value for set check');
+
+class MadeFieldClass extends BaseClass { myField = myField as unknown | string };
+class SecondMadeFieldClass extends BaseClass { myField = myField as unknown | string };
 const madeFieldInstance = new MadeFieldClass;
 const secondMadeFieldInstance = new MadeFieldClass;
 const thirdMadeFieldInstance = new SecondMadeFieldClass;
 
+class MadeReGet extends BaseClass { myField = myFieldReGet as unknown | string }
+class MadeReSet extends BaseClass { myField = myFieldReSet as unknown | string }
+const madeReGet = new MadeReGet;
+const madeReSet = new MadeReSet;
+
 describe('props tests', () => {
 
 	test('base instance has props', () => {
@@ -172,12 +218,45 @@ describe('props tests', () => {
 	});
 
 	test('correct custom field creation', () => {
-		expect(madeFieldInstance.myField).toEqual('zzz');
+		expect(madeFieldInstance.myField).toEqual('initial value');
 	});
+
 	test('correct custom field assignment', () => {
-		madeFieldInstance.myField = 123;
-		expect(secondMadeFieldInstance.myField).toEqual(123);
-		expect(thirdMadeFieldInstance.myField).toEqual(123);
+		madeFieldInstance.myField = 'replaced';
+		expect(secondMadeFieldInstance.myField).toEqual('replaced');
+		expect(thirdMadeFieldInstance.myField).toEqual('replaced');
+	});
+
+	test('correct custom field no-re-assignment', () => {
+		expect(madeReGet.myField).toEqual('initial value for get check');
+		expect(() => {
+
+			madeReGet.myField = 'replaced';
+
+		}).toThrow(new TypeError('Re-Assirnment is Forbidden'));
+	});
+
+	test('correct custom field setter only', () => {
+		madeReSet.myField = 'replaced';
+		expect(madeReSet.myField).toEqual('initial value for set check');
+	});
+
+	test('takes error on wrong field definition', () => {
+		expect(() => {
+			class WrongFieldConstructor extends FieldConstructor {
+				value: number
+				constructor(value: number) {
+					super(value)
+					this.value = value;
+				}
+			}
+			const wrongField = new WrongFieldConstructor(123);
+			class WithWrongField extends BaseClass {
+				erroredField = wrongField
+			}
+			new WithWrongField;
+
+		}).toThrow();
 	});
 
 	test('correct custom missing prop search creation', () => {
@@ -188,6 +267,10 @@ describe('props tests', () => {
 		const util = require('util');
 		// @ts-ignore
 		expect(madeFieldInstance[util.inspect.custom]).toEqual(undefined);
+		// @ts-ignore
+		const inspected = util.inspect(madeFieldInstance);
+		const expected = 'MadeFieldClass { myField: [Getter/Setter] }';
+		expect(expected).toEqual(expected);
 	});
 
 	test('wrong assignment to objects', () => {

package/{test/tsconfig.json → tsconfig.jest.json}

@@ -27,4 +27,8 @@
 			"node"
 		]
 	},
+	"include": [
+		"./src/**/*.ts",
+		"./test/**/*"
+	]
 }