feat: initial release

Author: leon19

.releaserc

@@ -0,0 +1,10 @@
+{
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/github",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    "@semantic-release/npm",
+    "@semantic-release/git"
+  ]
+}

README.md

@@ -1,24 +1,151 @@
 # @lleon/object-builders
 
+Library to easily create object builders, useful for testing or for generating seed data.
+
+This library requires
+[ES Proxies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy)
+to work. So be sure your browser or the node version you're using supports proxies.
+
+- [Installation](#installation)
+  - [fromInterface()](#frominterface--)
+  - [fromClassObject()](#fromclassobject--)
+  - [fromClassConstructor()](#fromclassconstructor--)
+  - [fromFactory()](#fromfactory--)
+- [Development](#development)
+  - [yarn build:commonjs](#yarn-build-commonjs)
+  - [yarn build:commonjs](#yarn-build-commonjs-1)
+  - [yarn build:esm](#yarn-build-esm)
+  - [yarn clean](#yarn-clean)
+  - [yarn test](#yarn-test)
+  - [yarn cover](#yarn-cover)
+  - [yarn lint](#yarn-lint)
+  - [yarn lint:fix](#yarn-lint-fix)
+
+## Installation
+
+```sh
+yarn add @lleon/object-builders
+
+# or using npm...
+npm install @lleon/object-builders
+```
+
+The project use [husky](https://github.com/typicode/husky) and
+[lint-staged](https://github.com/okonet/lint-staged) for linting and fixing possible errors on
+source code before commit
+
+### fromInterface()
+
+Creates a new object builder typed from an interface
+
+```ts
+import { fromInterface } from '@lleon/object-builders';
+
+interface User {
+  name: string;
+}
+
+const user = fromInterface<User>()
+  .name.set('John')
+  .build();
+
+console.log(user.name); // prints "John"
+```
+
+### fromClassObject()
+
+Creates a new object builder from the given class. The properties that can be set are the same
+properties as the class has.
+
+When using this builder object is instantiated using `Object.create` so the function constructor is
+never called.
+
+This is a good builder when using in conjunction with
+[class-transformer](https://www.npmjs.com/package/class-transformer) and
+[class-validators](https://www.npmjs.com/package/class-validator)
+
+```ts
+import { fromClassObject } from '@lleon/object-builders';
+import { IsString } from 'class-validators';
+
+class User {
+  @IsString()
+  name!: string;
+}
+
+const user = fromClassObject(User)
+  .name.set('John')
+  .build();
+
+console.log(user instanceof User); // prints `true`
+console.log(user.name); // prints "John"
+```
+
+### fromClassConstructor()
+
+Creates a new object builder from the given class. The class must receive an object as unique
+argument. In this case the object is instantiated using the `new` operator
+
+```ts
+import { fromClassConstructor } from '@lleon/object-builders';
+
+class User {
+  givenName: string;
+  familyName: string;
+
+  constructor({ firstName, lastName }: { firstName: string; lastName: string }) {
+    this.givenName = firstName;
+    this.familyName = lastName;
+  }
+}
+
+// the available builder properties are the properties that receives the constructor
+const user = fromClassConstructor(User)
+  .firstName.set('John')
+  .lastName.set('Doe')
+  .build();
+
+console.log(user instanceof User); // prints `true`
+console.log(user.givenName); // prints "John"
+console.log(user.familyName); // prints "Doe"
+```
+
+### fromFactory()
+
+Creates a new builder using the given factory function. Using a factory allow you to return any type
+you want not just objects
+
+```ts
+import { fromFactory } from '@lleon/object-builders';
+
+const factory = (properties: Partial<{ userName: string }>): string => {
+  return properties.userName || '';
+};
+
+const userName = fromFactory(factory)
+  .userName.set('john.doe1')
+  .build();
+
+console.log(userName === 'john.doe1'); // prints `true`
+```
+
 ## Development
 
 The project use [husky](https://github.com/typicode/husky) and
 [lint-staged](https://github.com/okonet/lint-staged) for linting and fixing possible errors on
 source code before commit
 
-Git hooks scripts are installed after running `yarn` the first time
+### yarn build
+
+Concurrently run `build:commonjs` and `build:esm`
 
 ### yarn build:commonjs
 
 Compile typescript files from the `src` folder inside the `lib` folder
 
 ### yarn build:esm
 
-Compile typescript files from the `src` folder inside the `esm` folder using es modules
-
-### yarn build
-
-Concurrently run both `build:commonjs` and `build:esm`
+Compile typescript files from the `src` folder inside the `esm` folder using ES modules
 
 ### yarn clean
 
@@ -30,7 +157,7 @@ Remove the following directories/files
 
 ### yarn test
 
-Run tests files inside the `tests` folder that matches the following patterns. Exit with code > 0 on
+Run tests files inside the `tests` and `src` folders that matches the following patterns. Exit with code > 0 on
 error
 
 - **\*.test.ts**

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lleon/object-builders",
-  "version": "0.0.0",
+  "version": "0.0.0-development",
   "description": "Utilities for building shaped objects and classes",
   "main": "lib/index.js",
   "module": "esm/index.js",
@@ -29,6 +29,8 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@semantic-release/changelog": "^3.0.4",
+    "@semantic-release/git": "^7.0.16",
     "@types/chai": "^4.2.3",
     "@types/mocha": "^5.2.7",
     "@typescript-eslint/eslint-plugin": "^2.3.1",
@@ -44,6 +46,7 @@
     "nyc": "^14.1.1",
     "prettier": "^1.18.2",
     "semantic-release": "^15.13.24",
+    "ts-mockito": "^2.5.0",
     "ts-node": "^8.4.1",
     "typescript": "^3.6.3"
   },

src/builders/fromClassConstructor.spec.ts

@@ -0,0 +1,53 @@
+import { expect } from 'chai';
+import { anyFunction, reset, spy, verify } from 'ts-mockito';
+import { fromClassConstructor } from './fromClassConstructor';
+import * as builder from './fromFactory';
+
+describe('fromClassConstructor()', () => {
+  let spiedBuilder: typeof builder;
+
+  beforeEach(() => (spiedBuilder = spy(builder)));
+  afterEach(() => reset(spiedBuilder));
+
+  it('should call fromFactory()', () => {
+    getTestBuilder();
+
+    verify(spiedBuilder.fromFactory(anyFunction())).once();
+  });
+
+  describe('#get()', () => {
+    it('should return a plain object with the set properties', () => {
+      const value = 'foo';
+      const test = getTestBuilder()
+        .property.set(value)
+        .get();
+
+      expect(test).to.not.be.instanceOf(Test);
+      expect(test.property).to.be.equal(value);
+    });
+  });
+
+  describe('#build()', () => {
+    it('should return a class instance with the set properties', () => {
+      const value = 'foo';
+      const test = getTestBuilder()
+        .property.set(value)
+        .build();
+
+      expect(test).to.be.instanceOf(Test);
+      expect(test.testProperty).to.be.equal(value);
+    });
+  });
+});
+
+class Test {
+  testProperty?: string;
+
+  constructor(properties: { property?: string }) {
+    this.testProperty = properties.property;
+  }
+}
+
+function getTestBuilder() {
+  return fromClassConstructor(Test);
+}

src/builders/fromClassConstructor.ts

@@ -0,0 +1,8 @@
+import { Builder } from '../types/Builder';
+import { fromFactory } from './fromFactory';
+
+export function fromClassConstructor<Instance extends object, Properties extends object>(classConstructor: {
+  new (properties: Properties): Instance;
+}): Builder<Properties, Instance> {
+  return fromFactory(properties => new classConstructor(properties as Properties));
+}

src/builders/fromClassObject.spec.ts

@@ -0,0 +1,49 @@
+import { expect } from 'chai';
+import { anyFunction, reset, spy, verify } from 'ts-mockito';
+import { fromClassObject } from './fromClassObject';
+import * as builder from './fromFactory';
+
+describe('fromClassObject()', () => {
+  let spiedBuilder: typeof builder;
+
+  beforeEach(() => (spiedBuilder = spy(builder)));
+  afterEach(() => reset(spiedBuilder));
+
+  it('should call fromFactory()', () => {
+    getTestBuilder();
+
+    verify(spiedBuilder.fromFactory(anyFunction())).once();
+  });
+
+  describe('#get()', () => {
+    it('should return a plain object with the set properties', () => {
+      const value = 'foo';
+      const test = getTestBuilder()
+        .testProperty.set(value)
+        .get();
+
+      expect(test).to.not.be.instanceOf(Test);
+      expect(test.testProperty).to.be.equal(value);
+    });
+  });
+
+  describe('#build()', () => {
+    it('should return a class instance with the set properties', () => {
+      const value = 'foo';
+      const test = getTestBuilder()
+        .testProperty.set(value)
+        .build();
+
+      expect(test).to.be.instanceOf(Test);
+      expect(test.testProperty).to.be.equal(value);
+    });
+  });
+});
+
+class Test {
+  testProperty?: string;
+}
+
+function getTestBuilder() {
+  return fromClassObject(Test);
+}

src/builders/fromClassObject.ts

@@ -0,0 +1,11 @@
+import { Builder } from '../types/Builder';
+import { ClassProperties } from '../types/ClassProperties';
+import { fromFactory } from './fromFactory';
+
+export function fromClassObject<T extends object>(classConstructor: { new (...args: any[]): T }): Builder<ClassProperties<T>, T> {
+  return fromFactory(properties => {
+    const instance = Object.create(classConstructor.prototype);
+
+    return Object.assign(instance, properties);
+  });
+}

src/builders/fromFactory.spec.ts

@@ -0,0 +1,68 @@
+import { expect } from 'chai';
+import { deepEqual, reset, spy, verify } from 'ts-mockito';
+import * as builder from '../makeBuilder';
+import { fromFactory } from './fromFactory';
+
+describe('fromFactory()', () => {
+  let spiedBuilder: typeof builder;
+  let spiedFactory: typeof factoryWrapper;
+
+  beforeEach(() => {
+    spiedBuilder = spy(builder);
+    spiedFactory = spy(factoryWrapper);
+  });
+
+  afterEach(() => {
+    reset(spiedBuilder);
+    reset(spiedFactory);
+  });
+
+  it('should call fromFactory()', () => {
+    getTestBuilder();
+
+    verify(spiedBuilder.makeBuilder(factoryWrapper.factory)).once();
+  });
+
+  describe('#get()', () => {
+    it('should return a plain object with the set properties', () => {
+      const value = 'foo';
+      const test = getTestBuilder()
+        .testInputProperty.set(value)
+        .get();
+
+      expect(test).to.not.be.instanceOf(TestResult);
+      expect(test.testInputProperty).to.be.equal(value);
+    });
+  });
+
+  describe('#build()', () => {
+    it('should return a class instance with the set properties', () => {
+      const value = 'foo';
+      const builder = getTestBuilder().testInputProperty.set(value);
+      const test = builder.build();
+
+      verify(spiedFactory.factory(deepEqual(builder.get()))).once();
+
+      expect(test).to.be.instanceOf(TestResult);
+      expect(test.testResultProperty).to.be.equal(value);
+    });
+  });
+});
+
+interface TestInput {
+  testInputProperty: string;
+}
+
+class TestResult {
+  constructor(readonly testResultProperty?: string) {}
+}
+
+const factoryWrapper = {
+  factory(input: Partial<TestInput>): TestResult {
+    return new TestResult(input.testInputProperty);
+  }
+};
+
+function getTestBuilder() {
+  return fromFactory(factoryWrapper.factory);
+}