@e22m4u/js-repository 0.1.1 → 0.1.3

package/src/schema.spec.ts

@@ -0,0 +1,115 @@
+import {expect} from 'chai';
+import {Schema} from './schema.js';
+import {Repository} from './repository/index.js';
+import {DefinitionRegistry} from './definition/index.js';
+import {PropertyValidatorRegistry} from './definition/index.js';
+
+describe('Schema', function () {
+  describe('defineDatasource', function () {
+    it('returns this', function () {
+      const schema = new Schema();
+      const res = schema.defineDatasource({
+        name: 'datasource',
+        adapter: 'memory',
+      });
+      expect(res).to.be.eq(schema);
+    });
+
+    it('sets the datasource definition', function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      const res =
+        schema.getService(DefinitionRegistry).getDatasource('datasource');
+      expect(res).to.be.eql({name: 'datasource', adapter: 'memory'});
+    });
+
+    it('throws an error if the datasource name already defined', function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      const throwable =
+        () => schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      expect(throwable).to.throw(
+        'The datasource "datasource" is already defined.',
+      );
+    });
+  });
+
+  describe('defineModel', function () {
+    it('returns this', function () {
+      const schema = new Schema();
+      const res = schema.defineModel({name: 'model'});
+      expect(res).to.be.eq(schema);
+    });
+
+    it('sets the model definition', function () {
+      const schema = new Schema();
+      schema.defineModel({name: 'model'});
+      const res = schema.getService(DefinitionRegistry).getModel('model');
+      expect(res).to.be.eql({name: 'model'});
+    });
+
+    it('throws an error if the model name already defined', function () {
+      const schema = new Schema();
+      schema.defineModel({name: 'model'});
+      const throwable = () => schema.defineModel({name: 'model'});
+      expect(throwable).to.throw('The model "model" is already defined.');
+    });
+  });
+
+  describe('getRepository', function () {
+    it('returns a repository by the model name', function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const res = schema.getRepository('model');
+      expect(res).to.be.instanceof(Repository);
+    });
+
+    it('throws an error if the model is not defined', function () {
+      const schema = new Schema();
+      const throwable = () => schema.getRepository('model');
+      expect(throwable).to.throw('The model "model" is not defined.');
+    });
+
+    it('uses generic types to define the repository type', function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      interface MyModel {
+        myId: number;
+      }
+      const res1: Repository = schema.getRepository('model');
+      const res2: Repository<MyModel, number, 'myId'> =
+        schema.getRepository<MyModel, number, 'myId'>('model');
+      expect(res1).to.be.eq(res2);
+    });
+  });
+
+  describe('addPropertyValidator', function () {
+    it('returns this', function () {
+      const schema = new Schema();
+      const res = schema.addPropertyValidator('validator', () => true);
+      expect(res).to.be.eq(schema);
+    });
+
+    it('adds a new property validator', function () {
+      const schema = new Schema();
+      const validator = () => true;
+      schema.addPropertyValidator('validator', validator);
+      const res = schema.getService(PropertyValidatorRegistry)
+        .getValidator('validator');
+      expect(res).to.be.eq(validator);
+    });
+
+    it('throws an error for already existing validator name', function () {
+      const schema = new Schema();
+      const validator = () => true;
+      schema.addPropertyValidator('validator', validator);
+      const throwable =
+        () => schema.addPropertyValidator('validator', validator);
+      expect(throwable).to.throw(
+        'The property validator "validator" is already defined.',
+      );
+    });
+  });
+});

package/src/types.d.ts

@@ -28,3 +28,11 @@ export declare type ModelId = unknown;
  */
 type Identity<T> = T;
 export declare type Flatten<T> = Identity<{[k in keyof T]: T[k]}>;
+
+/**
+ * A callable type with the "new" operator
+ * allows class and constructor.
+ */
+export interface Constructor<T = unknown> {
+  new (...args: any[]): T;
+}

package/src/types.js

@@ -0,0 +1 @@
+export {};

package/src/utils/get-decorator-target-type.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Decorator target type.
+ */
+export declare enum DecoratorTargetType {
+  CONSTRUCTOR = 'constructor',
+  INSTANCE = 'instance',
+  STATIC_METHOD = 'staticMethod',
+  INSTANCE_METHOD = 'instanceMethod',
+  STATIC_PROPERTY = 'staticProperty',
+  INSTANCE_PROPERTY = 'instanceProperty',
+  CONSTRUCTOR_PARAMETER = 'constructorParameter',
+  STATIC_METHOD_PARAMETER = 'staticMethodParameter',
+  INSTANCE_METHOD_PARAMETER = 'instanceMethodParameter',
+}
+
+/**
+ * Get decorator target type.
+ *
+ * @param target
+ * @param propertyKey
+ * @param descriptorOrIndex
+ */
+export declare function getDecoratorTargetType(
+  target: object,
+  propertyKey?: string,
+  descriptorOrIndex?: PropertyDescriptor | number,
+): DecoratorTargetType;

package/src/utils/get-decorator-target-type.js

@@ -0,0 +1,63 @@
+/**
+ * @typedef {object} PropertyDescriptor
+ * @property {boolean|undefined} configurable
+ * @property {boolean|undefined} enumerable
+ * @property {*} value
+ * @property {boolean|undefined} writable
+ * @property {Function} get
+ * @property {Function} set
+ */
+
+/**
+ * Decorator target type.
+ *
+ * @enum {string}
+ * @property {string} CONSTRUCTOR
+ * @property {string} INSTANCE
+ * @property {string} STATIC_METHOD
+ * @property {string} INSTANCE_METHOD
+ * @property {string} STATIC_PROPERTY
+ * @property {string} INSTANCE_PROPERTY
+ * @property {string} CONSTRUCTOR_PARAMETER
+ * @property {string} STATIC_METHOD_PARAMETER
+ * @property {string} INSTANCE_METHOD_PARAMETER
+ */
+export const DecoratorTargetType = {
+  CONSTRUCTOR: 'constructor',
+  INSTANCE: 'instance',
+  STATIC_METHOD: 'staticMethod',
+  INSTANCE_METHOD: 'instanceMethod',
+  STATIC_PROPERTY: 'staticProperty',
+  INSTANCE_PROPERTY: 'instanceProperty',
+  CONSTRUCTOR_PARAMETER: 'constructorParameter',
+  STATIC_METHOD_PARAMETER: 'staticMethodParameter',
+  INSTANCE_METHOD_PARAMETER: 'instanceMethodParameter',
+};
+
+/**
+ * Get decorator target type.
+ *
+ * @param {object} target
+ * @param {string|undefined} propertyKey
+ * @param {PropertyDescriptor|number|undefined} descriptorOrIndex
+ * @returns {DecoratorTargetType}
+ */
+export function getDecoratorTargetType(target, propertyKey, descriptorOrIndex) {
+  const isCtor = typeof target === 'function';
+  const isParameter = typeof descriptorOrIndex === 'number';
+  const isProperty = propertyKey != null && descriptorOrIndex == null;
+  const isMethod = propertyKey != null && descriptorOrIndex != null;
+  const D = DecoratorTargetType;
+  if (isCtor) {
+    if (isParameter)
+      return propertyKey ? D.STATIC_METHOD_PARAMETER : D.CONSTRUCTOR_PARAMETER;
+    if (isProperty) return D.STATIC_PROPERTY;
+    if (isMethod) return D.STATIC_METHOD;
+    return D.CONSTRUCTOR;
+  } else {
+    if (isParameter) return D.INSTANCE_METHOD_PARAMETER;
+    if (isProperty) return D.INSTANCE_PROPERTY;
+    if (isMethod) return D.INSTANCE_METHOD;
+    return D.INSTANCE;
+  }
+}

package/src/utils/get-decorator-target-type.spec.js

@@ -0,0 +1,77 @@
+import {expect} from 'chai';
+import {getDecoratorTargetType} from './get-decorator-target-type.js';
+import {DecoratorTargetType as DTT} from './get-decorator-target-type.js';
+
+describe('getDecoratorTargetType', function () {
+  const validate = function (value) {
+    return function (target, propertyKey, descriptorOrIndex) {
+      const type = getDecoratorTargetType(
+        target,
+        propertyKey,
+        descriptorOrIndex,
+      );
+      expect(value).to.be.eq(type);
+    };
+  };
+
+  it('returns CONSTRUCTOR', function () {
+    class Target {}
+    validate(DTT.CONSTRUCTOR)(Target);
+  });
+
+  it('returns INSTANCE', function () {
+    class Target {}
+    validate(DTT.INSTANCE)(Target.prototype);
+  });
+
+  it('returns STATIC_METHOD', function () {
+    class Target {
+      static method() {}
+    }
+    const desc = Object.getOwnPropertyDescriptor(Target, 'method');
+    validate(DTT.STATIC_METHOD)(Target, 'method', desc);
+  });
+
+  it('returns INSTANCE_METHOD', function () {
+    class Target {
+      method() {}
+    }
+    const desc = Object.getOwnPropertyDescriptor(Target.prototype, 'method');
+    validate(DTT.INSTANCE_METHOD)(Target.prototype, 'method', desc);
+  });
+
+  it('returns STATIC_PROPERTY', function () {
+    class Target {
+      static prop;
+    }
+    validate(DTT.STATIC_PROPERTY)(Target, 'prop');
+  });
+
+  it('returns INSTANCE_PROPERTY', function () {
+    class Target {
+      prop;
+    }
+    validate(DTT.INSTANCE_PROPERTY)(Target.prototype, 'prop');
+  });
+
+  it('returns CONSTRUCTOR_PARAMETER', function () {
+    class Target {
+      constructor(param) {}
+    }
+    validate(DTT.CONSTRUCTOR_PARAMETER)(Target, undefined, 0);
+  });
+
+  it('returns STATIC_METHOD_PARAMETER', function () {
+    class Target {
+      static method(param) {}
+    }
+    validate(DTT.STATIC_METHOD_PARAMETER)(Target, 'method', 0);
+  });
+
+  it('returns INSTANCE_METHOD_PARAMETER', function () {
+    class Target {
+      method(param) {}
+    }
+    validate(DTT.INSTANCE_METHOD_PARAMETER)(Target.prototype, 'method', 0);
+  });
+});

package/src/utils/index.d.ts

@@ -8,3 +8,4 @@ export * from './string-to-regexp.js';
 export * from './get-value-by-path.js';
 export * from './select-object-keys.js';
 export * from './exclude-object-keys.js';
+export * from './get-decorator-target-type.js';

package/src/utils/index.js

@@ -8,3 +8,4 @@ export * from './string-to-regexp.js';
 export * from './get-value-by-path.js';
 export * from './select-object-keys.js';
 export * from './exclude-object-keys.js';
+export * from './get-decorator-target-type.js';

package/src/utils/is-ctor.d.ts

@@ -1,5 +1,6 @@
 /**
- * Is ctor.
+ * Returns true if the given value
+ * is a constructor function or a class.
  *
  * @param {*} value
  * @returns {boolean}

package/src/utils/is-ctor.js

@@ -1,5 +1,6 @@
 /**
- * Is ctor.
+ * Returns true if the given value
+ * is a constructor function or a class.
  *
  * @param {*} value
  * @returns {boolean}

package/src/utils/is-ctor.spec.js

@@ -1,7 +1,7 @@
 import {expect} from 'chai';
 import {isCtor} from './is-ctor.js';
 
-describe('isConstructor', function () {
+describe('isCtor', function () {
   it('returns true if a given value is a constructor', function () {
     expect(isCtor(Date)).to.be.true;
     expect(isCtor(Number)).to.be.true;

package/tsconfig.json

@@ -1,9 +1,11 @@
 {
   "compilerOptions": {
+    "strict": true,
     "rootDir": "src",
     "noEmit": true,
     "target": "es2022",
     "module": "NodeNext",
-    "moduleResolution": "NodeNext"
+    "moduleResolution": "NodeNext",
+    "strictNullChecks": true
   }
 }