@e22m4u/js-repository 0.1.0 → 0.1.2

package/src/adapter/builtin/memory-adapter.spec.js

@@ -187,6 +187,64 @@ describe('MemoryAdapter', function () {
       expect(tableData).to.be.eql({...input, [DEF_PK]: idValue});
     });
 
+    it('generates a new identifier when a value of a primary key is an empty string', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {
+        [DEF_PK]: '',
+        foo: 'string',
+        bar: 10,
+      };
+      const created = await adapter.create('model', input);
+      const idValue = created[DEF_PK];
+      expect(idValue).to.be.not.eq('');
+      expect(created).to.be.eql({...input, [DEF_PK]: idValue});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({...input, [DEF_PK]: idValue});
+    });
+
+    it('generates a new identifier when a value of a primary key is zero', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {
+        [DEF_PK]: 0,
+        foo: 'string',
+        bar: 10,
+      };
+      const created = await adapter.create('model', input);
+      const idValue = created[DEF_PK];
+      expect(idValue).to.be.not.eq(0);
+      expect(created).to.be.eql({...input, [DEF_PK]: idValue});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({...input, [DEF_PK]: idValue});
+    });
+
     it('generates a new identifier for a primary key of a "number" type', async function () {
       const schema = new Schema();
       schema.defineDatasource({
@@ -1214,6 +1272,64 @@ describe('MemoryAdapter', function () {
       expect(tableData).to.be.eql({...input, [DEF_PK]: idValue});
     });
 
+    it('generates a new identifier when a value of a primary key is an empty string', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {
+        [DEF_PK]: '',
+        foo: 'string',
+        bar: 10,
+      };
+      const created = await adapter.replaceOrCreate('model', input);
+      const idValue = created[DEF_PK];
+      expect(idValue).to.be.not.eq('');
+      expect(created).to.be.eql({...input, [DEF_PK]: idValue});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({...input, [DEF_PK]: idValue});
+    });
+
+    it('generates a new identifier when a value of a primary key is zero', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {
+        [DEF_PK]: 0,
+        foo: 'string',
+        bar: 10,
+      };
+      const created = await adapter.replaceOrCreate('model', input);
+      const idValue = created[DEF_PK];
+      expect(idValue).to.be.not.eq(0);
+      expect(created).to.be.eql({...input, [DEF_PK]: idValue});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({...input, [DEF_PK]: idValue});
+    });
+
     it('generates a new identifier for a primary key of a "number" type', async function () {
       const schema = new Schema();
       schema.defineDatasource({

package/src/adapter/decorator/data-sanitizing-decorator.d.ts

@@ -1,3 +1,4 @@
+import {Adapter} from '../adapter.js';
 import {Service} from '@e22m4u/js-service';
 
 /**
@@ -9,5 +10,5 @@ export declare class DataSanitizingDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/adapter/decorator/data-validation-decorator.d.ts

@@ -1,4 +1,5 @@
 import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter.js';
 
 /**
  * Data validation decorator.
@@ -9,5 +10,5 @@ export declare class DataValidationDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/adapter/decorator/default-values-decorator.d.ts

@@ -1,4 +1,5 @@
 import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter.js';
 
 /**
  * Default values decorator.
@@ -9,5 +10,5 @@ export declare class DefaultValuesDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/adapter/decorator/fields-filtering-decorator.d.ts

@@ -1,4 +1,5 @@
 import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter.js';
 
 /**
  * Fields filtering decorator.
@@ -9,5 +10,5 @@ export declare class FieldsFilteringDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/adapter/decorator/inclusion-decorator.d.ts

@@ -1,4 +1,5 @@
 import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter.js';
 
 /**
  * Inclusion decorator.
@@ -9,5 +10,5 @@ export declare class InclusionDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/definition/model/index.js

@@ -1,5 +1,6 @@
 export * from './relations/index.js';
 export * from './properties/index.js';
+export * from './model-definition.js';
 export * from './model-data-validator.js';
 export * from './model-data-sanitizer.js';
 export * from './model-definition-utils.js';

package/src/definition/model/model-definition.js

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

package/src/definition/model/properties/index.js

@@ -1,3 +1,4 @@
 export * from './data-type.js';
+export * from './property-definition.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';

package/src/definition/model/properties/property-definition.js

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

package/src/definition/model/relations/index.js

@@ -1,2 +1,3 @@
 export * from './relation-type.js';
+export * from './relation-definition.js';
 export * from './relations-definition-validator.js';

package/src/definition/model/relations/relation-definition.js

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

package/src/filter/filter-clause.d.ts

@@ -43,8 +43,8 @@ export declare type ItemFilterClause = Pick<FilterClause, 'fields' | 'include'>;
  * ```
  */
 export declare type WhereClause =
-  & AndClause
-  & OrClause
+  & Partial<AndClause>
+  & Partial<OrClause>
   & PropertiesClause;
 
 /**
@@ -124,7 +124,7 @@ export declare type OperatorClause = {
  * ```
  */
 export interface AndClause {
-  and?: WhereClause[];
+  and: WhereClause[];
 }
 
 /**
@@ -138,7 +138,7 @@ export interface AndClause {
  * ```
  */
 export interface OrClause {
-  or?: WhereClause[];
+  or: WhereClause[];
 }
 
 /**

package/src/index.d.ts

@@ -1,8 +1,8 @@
 export * from './types.js';
 export * from './schema.js';
 export * from './utils/index.js';
-export * from './filter/index.js';
 export * from './errors/index.js';
+export * from './filter/index.js';
 export * from './adapter/index.js';
 export * from './relations/index.js';
 export * from './definition/index.js';

package/src/index.js

@@ -1,3 +1,4 @@
+export * from './types.js';
 export * from './schema.js';
 export * from './utils/index.js';
 export * from './errors/index.js';

package/src/repository/repository.d.ts

@@ -14,11 +14,17 @@ import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME} from '../definition/index.js';
  * Repository.
  */
 export declare class Repository<
-  Data extends ModelData = ModelData,
+  Data extends object = ModelData,
   IdType extends ModelId = ModelId,
   IdName extends string = DEFAULT_PRIMARY_KEY_PROPERTY_NAME,
   FlatData extends ModelData = Flatten<Data>,
 > extends Service {
+  // it fixes unused generic bug
+  private _Data?: Data;
+  private _IdType?: IdType;
+  private _IdName?: IdName;
+  private _FlatData?: FlatData;
+
   /**
    * Model name.
    */
@@ -162,7 +168,7 @@ type WithoutId<IdName extends string, Data extends ModelData> = Flatten<
 /**
  * Makes fields as optional and remove id field.
  */
-type PartialWithoutId<IdName extends string, Data extends ModelData> = Flatten<
+type PartialWithoutId<IdName extends string, Data extends object> = Flatten<
   Partial<Omit<Data, IdName>>
 >;
 
@@ -171,5 +177,5 @@ type PartialWithoutId<IdName extends string, Data extends ModelData> = Flatten<
  */
 type OptionalUnlessRequiredId<
   IdName extends string,
-  Data extends ModelData,
+  Data extends object,
 > = Flatten<Data extends {[K in IdName]: any} ? PartialBy<Data, IdName> : Data>;

package/src/repository/repository.js

@@ -3,7 +3,6 @@ import {Adapter} from '../adapter/index.js';
 import {AdapterRegistry} from '../adapter/index.js';
 import {InvalidArgumentError} from '../errors/index.js';
 import {DefinitionRegistry} from '../definition/index.js';
-import {ModelDefinitionUtils} from '../definition/index.js';
 
 /**
  * Repository.

package/src/schema.d.ts

@@ -30,7 +30,7 @@ export declare class Schema extends Service {
    * @param modelName
    */
   getRepository<
-    Data extends ModelData = ModelData,
+    Data extends object = ModelData,
     IdType extends ModelId = ModelId,
     IdName extends string = DEFAULT_PRIMARY_KEY_PROPERTY_NAME,
   >(modelName: string): Repository<Data, IdType, IdName>;

package/src/schema.spec.ts

@@ -0,0 +1,71 @@
+import {expect} from 'chai';
+import {Schema} from './schema.js';
+import {Repository} from './repository/index.js';
+import {DefinitionRegistry} from './definition/index.js';
+
+describe('Schema', function () {
+  describe('defineDatasource', function () {
+    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('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);
+    });
+  });
+});

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
   }
 }