backend-test-tools 1.0.0

package/.env.example

@@ -0,0 +1,51 @@
+##########
+# Server #
+##########
+
+# General server settings
+
+# Port on which the server is served
+PORT=
+
+######################
+# JWT Authentication #
+######################
+
+# Settings for the Json Web Token generator
+
+# URL of the main API (token audience)
+API_URL=
+
+# Auth0 domain (token issuer)
+AUTH0_DOMAIN=
+
+# Secret used to sign tokens symmetrically
+JWT_SECRET=
+
+######################
+# TLS Authentication #
+######################
+
+# Settings for the TLS public key infrastructure
+# /!\ The tool to make tls requests does not support encrypted private keys
+
+# Private key of the server
+TLS_SERVER_KEY=
+
+# Certificate of the server
+TLS_SERVER_CERT=
+
+# Certificate of the certifying authority
+TLS_CA=
+
+# Private key used to make a TLS request
+# Defaults to the server key if not specified
+TLS_REQUEST_KEY=
+
+# Certificate used to make a TLS request 
+# Defaults to the server certificate if not specified
+TLS_REQUEST_CERT=
+
+# Certificate of the certifying authority used to make a TLS request  
+# Defaults to the server certificate of the certifying authority if not specified
+TLS_REQUEST_CA=

package/.mocharc.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = {
+  require: ['tsconfig-paths/register', 'ts-node/register', `${process.cwd()}/test/env`],
+  ui: 'bdd',
+  reporter: 'nyan',
+  exit: true,
+  extension: ['ts'],
+};

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "printWidth": 100,
+  "trailingComma": "none"
+}

package/README.md

@@ -0,0 +1,271 @@
+# Node test tools
+
+Tools to be used by the Node backend services for testing purpose.
+
+## Table of contents
+
+- [Node test tools](#backend-test-tools)
+  - [Table of contents](#table-of-contents)
+  - [Generators](#generators)
+    - [Access token](#access-token)
+    - [Social provider](#social-provider)
+    - [Auth0 ID](#auth0-id)
+    - [Chat ID](#chat-id)
+    - [Locale](#locale)
+    - [RegId](#regid)
+    - [RSA Key Pair](#rsa-key-pair)
+    - [User public key](#user-public-key)
+    - [User encrypted private key](#user-encrypted-private-key)
+    - [User encrypted blackberry passcode](#user-encrypted-blackberry-passcode)
+  - [Factory](#factory)
+    - [Build](#build)
+    - [Models](#models)
+      - [Connection](#connection)
+      - [Identity](#identity)
+      - [Organization](#organization)
+      - [User](#user)
+  - [Utilities](#utilities)
+    - [TLS](#tls)
+      - [Certificate generation](#certificate-generation)
+      - [Secured request](#secured-request)
+    - [Json Web token](#json-web-token)
+      - [Bearer token](#bearer-token)
+      - [Token authenticated request](#token-authenticated-request)
+
+## Generators
+
+Generators generate some commonly used fake data.
+
+### Access token
+
+Generate an mock access token like Auth0 would do.
+The payload and options can be customized if needed. Please refer to the [jsonwebtoken package](https://github.com/auth0/node-jsonwebtoken#jwtsignpayload-secretorprivatekey-options-callback "jsonwebtoken package") for documentation.
+This is a self signed token that is only valid in test environment.
+
+```javascript
+import {generateAccessToken} from 'backend-test-tools'
+const accessToken = generateAccessToken(payload, options)
+```
+
+### Social provider
+
+Get a random third party identity provider name.
+
+```javascript
+import {generateAuth0Provider} from 'backend-test-tools'
+const provider = generateAuth0Provider(options)
+```
+
+Options
+
+- **includeLocal** (Boolean): Include the provider name for users authenticating with an email/password combination. (default: false)
+
+### Auth0 ID
+
+Generate a fake auth0 ID.
+
+```javascript
+import {generateAuth0UserId} from 'backend-test-tools'
+const auth0Id = generateAuth0UserId(full)
+```
+
+- **full** (Boolean): prefix the provider name to the ID to create a full auth0 ID also known as externalID. (default: false)
+
+### Chat ID
+
+Get a random BlackBerry Spark chat ID
+
+```javascript
+import {generateChatId} from 'backend-test-tools'
+const chatId = generateChatId()
+```
+
+### Locale
+
+Get a random locale from the ones available.
+
+```javascript
+import {generateLocale} from 'backend-test-tools'
+const locale = generateLocale()
+```
+
+### RegId
+
+Get a random Blackberry Spark regId.
+
+```javascript
+import {generateRegId} from 'backend-test-tools'
+const regId = generateRegId()
+```
+
+### RSA Key Pair
+
+Get RSA key pair and save to certs folder.
+
+Note. use on test/env.js
+
+```javascript
+import {generateRsaKeyPair} from 'backend-test-tools'
+generateRsaKeyPair()
+```
+
+### User public key
+
+Get a fake base64 string that looks like a user public key.
+/!\ This is not a valid crypto key
+
+```javascript
+import {generateSignKeyPub} from 'backend-test-tools'
+const signKeyPub = generateSignKeyPub()
+```
+
+### User encrypted private key
+
+Get a fake base64 string that looks like a user encrypted private key.
+/!\ This is not a valid crypto key
+
+```javascript
+import {generateSignKeyEncrypted} from 'backend-test-tools'
+const signKeyEncrypted = generateSignKeyEncrypted()
+```
+
+### User encrypted blackberry passcode
+
+Get a fake base64 string that looks like a user encrypted Blackberry passcode.
+/!\ This is not a valid crypto key
+
+```javascript
+import {generateBbEncrypted} from 'backend-test-tools'
+const bbEncrypted = generateBbEncrypted()
+```
+
+## Factory
+
+Factory functions generate commonly used entities.
+They are heavily inspired by [factory-girl](https://github.com/simonexmachina/factory-girl#readme "factory-girl") and the worker functions are fully compatible with it.
+
+### Build
+
+Build an object according to a model.
+
+```javascript
+import {factory} from 'backend-test-tools'
+const model = factory.build(name, attributes, buildOptions)
+const models = factory.buildMany(name, count, attributes, buildOptions)
+```
+
+- **name**: Name of the model to user.
+- **count**: Number of objects to generate.
+- **attributes**: Override the value of some of the object's attributes.
+- **buildOptions**: Options passed to the workers.
+
+### Models
+
+#### Connection
+
+```javascript
+import {factory} from 'backend-test-tools'
+const buildOptions = {
+ accepted: true,
+ blocked: false
+}
+const model = factory.build('connection', undefined, buildOptions)
+```
+
+- **accepted**: Will set the connection as accepted, and set the acceptedAt accordingly.
+- **blocked**: Will set the connection as blocked, and set the blockedAt accordingly.
+
+#### Identity
+
+```javascript
+import {factory} from 'backend-test-tools'
+const model = factory.build('identity')
+```
+
+#### Organization
+
+```javascript
+import {factory} from 'backend-test-tools'
+const model = factory.build('organization')
+```
+
+#### User
+
+```javascript
+import {factory} from 'backend-test-tools'
+const buildOptions = {
+ firstName: John,
+ lastName: Doe,
+ organizationId: '51f0ac7a-4b79-485f-9a0f-a0eb7a5d8aa8',
+ admin: false,
+ member: false,
+ moreRandom: false
+}
+const model = factory.build('user', undefined, buildOptions)
+```
+
+- **firstName**: First name of the user, will also define all the variations of name.
+- **lastName**: Last name of the user, will also define all the variations of name.
+- **organizationId**: Id of the organization to which the user is related. Will define the date at which he joined.
+- **admin**: User is admin of the organization.
+- **member**: User is a member of the organization.
+- **moreRandom**: Adds randomness to unique fields to avoid collisions when building a large number of objects.
+
+## Utilities
+
+Utility functions that bring some convenience when writing tests.
+
+### TLS
+
+#### Certificate generation
+
+To replicate a PKI (Public Key Infrastructure), a CA certificate is needed as well as client and server cert2ificates and private keys.
+
+```javascript
+import {generatePkiEnvironment} from 'backend-test-tools'
+generatePkiEnvironment()
+```
+
+This will right all the required certificates and keys at the root of the project in a directory called `certs`.
+
+#### Secured request
+
+The function `tlsRequest` is a wrapper around the [supertest](https://github.com/visionmedia/supertest "supertest") library that adds the required parameters for performing a tls request.
+
+```javascript
+import {tlsRequest} from 'backend-test-tools'
+tlsRequest(options)
+ .get('/test')
+ .expect(200);
+```
+
+options
+
+- **ca**: Override the default CA
+- **key**: Override the default private key
+- **cert**: Override the default certificate
+
+### Json Web token
+
+#### Bearer token
+
+This function generates a bearer token for a given user, it can therefore conveniently be added as authorization during tests.
+
+```javascript
+import {getBearer} from 'backend-test-tools'
+const authorization = getBearer(user, payload);
+```
+
+- **user**: The user making the request
+- **payload**: Data to include in the JWT payload
+
+#### Token authenticated request
+
+The function `jwtRequest` is a wrapper around the [supertest](https://github.com/visionmedia/supertest "supertest") library that adds the required parameters for performing a request authenticated by the bearer JWT of a specified user.
+
+```javascript
+import {jwtRequest} from 'backend-test-tools'
+jwtRequest(app, user)
+ .get('/test')
+ .expect(200);
+```

package/babel.config.json

@@ -0,0 +1,33 @@
+{
+  "presets": [
+    "@babel/preset-typescript",
+    [
+      "@babel/preset-env",
+      {
+        "targets": { "node": 20 },
+        "useBuiltIns": "entry",
+        "corejs": 3
+      }
+    ]
+  ],
+  "plugins": [
+    [
+      "module-resolver",
+      {
+        "root": "src",
+        "alias": {
+          "test": "test"
+        },
+        "extensions": [".js", ".ts"]
+      }
+    ],
+    "@babel/plugin-transform-class-properties",
+    "@babel/plugin-transform-classes",
+    "@babel/plugin-transform-runtime"
+  ],
+  "env": {
+    "test": {
+      "plugins": ["istanbul"]
+    }
+  }
+}

package/dist/factory/factory.d.ts

@@ -0,0 +1,11 @@
+import { FactoryModel, FactoryBuildOptions, FactoryModelOverride, FactoryReturnType } from './factory.types';
+export declare const factory: {
+    /**
+     * Build an object according to a defined model
+     */
+    build: <T extends FactoryModel>(name: T, attributes?: FactoryModelOverride<T>, buildOptions?: FactoryBuildOptions<T>) => FactoryReturnType<T>;
+    /**
+     * Build multiple objects according to a defined model
+     */
+    buildMany: <T extends FactoryModel>(name: T, count: number, attributes?: FactoryModelOverride<T>, buildOptions?: FactoryBuildOptions<T>) => Array<FactoryReturnType<T>>;
+};

package/dist/factory/factory.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.factory = void 0;
+var _crypto = require("crypto");
+var _workers = require("./workers");
+const modelsMap = {
+  connection: _workers.connectionFactoryWorker,
+  organization: _workers.organizationFactoryWorker,
+  user: _workers.userFactoryWorker
+};
+const factory = exports.factory = {
+  /**
+   * Build an object according to a defined model
+   */
+  build: function (name, attributes = {}, buildOptions = {}) {
+    if (!Object.keys(modelsMap).includes(name)) throw new Error(`Factory: unknown model "${name}"`);
+    const worker = modelsMap[name];
+    const instance = worker(buildOptions);
+    return {
+      id: (0, _crypto.randomUUID)(),
+      ...instance,
+      ...attributes
+    };
+  },
+  /**
+   * Build multiple objects according to a defined model
+   */
+  buildMany: function (name, count, attributes = {}, buildOptions = {}) {
+    const instances = [];
+    for (let i = 0; i < count; i++) {
+      instances.push(this.build(name, attributes, buildOptions));
+    }
+    return instances;
+  }
+};
+//# sourceMappingURL=factory.js.map

package/dist/factory/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","names":["_crypto","require","_workers","modelsMap","connection","connectionFactoryWorker","organization","organizationFactoryWorker","user","userFactoryWorker","factory","exports","build","name","attributes","buildOptions","Object","keys","includes","Error","worker","instance","id","randomUUID","buildMany","count","instances","i","push"],"sources":["../../src/factory/factory.ts"],"sourcesContent":["import {randomUUID} from 'crypto';\nimport {\n  FactoryModel,\n  FactoryBuildOptions,\n  FactoryModelOverride,\n  FactoryReturnType,\n  ModelsMap,\n} from './factory.types';\nimport {connectionFactoryWorker, organizationFactoryWorker, userFactoryWorker} from './workers';\n\nconst modelsMap: ModelsMap = {\n  connection: connectionFactoryWorker,\n  organization: organizationFactoryWorker,\n  user: userFactoryWorker,\n};\n\nexport const factory = {\n  /**\n   * Build an object according to a defined model\n   */\n  build: function <T extends FactoryModel>(\n    name: T,\n    attributes: FactoryModelOverride<T> = {},\n    buildOptions: FactoryBuildOptions<T> = {},\n  ): FactoryReturnType<T> {\n    if (!Object.keys(modelsMap).includes(name)) throw new Error(`Factory: unknown model \"${name}\"`);\n    const worker = modelsMap[name];\n    const instance = worker(buildOptions);\n    return {\n      id: randomUUID(),\n      ...instance,\n      ...attributes,\n    };\n  },\n\n  /**\n   * Build multiple objects according to a defined model\n   */\n  buildMany: function <T extends FactoryModel>(\n    name: T,\n    count: number,\n    attributes: FactoryModelOverride<T> = {},\n    buildOptions: FactoryBuildOptions<T> = {},\n  ): Array<FactoryReturnType<T>> {\n    const instances: Array<FactoryReturnType<T>> = [];\n    for (let i = 0; i < count; i++) {\n      instances.push(this.build(name, attributes, buildOptions));\n    }\n    return instances;\n  },\n};\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAQA,IAAAC,QAAA,GAAAD,OAAA;AAEA,MAAME,SAAoB,GAAG;EAC3BC,UAAU,EAAEC,gCAAuB;EACnCC,YAAY,EAAEC,kCAAyB;EACvCC,IAAI,EAAEC;AACR,CAAC;AAEM,MAAMC,OAAO,GAAAC,OAAA,CAAAD,OAAA,GAAG;EACrB;AACF;AACA;EACEE,KAAK,EAAE,SAAAA,CACLC,IAAO,EACPC,UAAmC,GAAG,CAAC,CAAC,EACxCC,YAAoC,GAAG,CAAC,CAAC,EACnB;IACtB,IAAI,CAACC,MAAM,CAACC,IAAI,CAACd,SAAS,CAAC,CAACe,QAAQ,CAACL,IAAI,CAAC,EAAE,MAAM,IAAIM,KAAK,CAAC,2BAA2BN,IAAI,GAAG,CAAC;IAC/F,MAAMO,MAAM,GAAGjB,SAAS,CAACU,IAAI,CAAC;IAC9B,MAAMQ,QAAQ,GAAGD,MAAM,CAACL,YAAY,CAAC;IACrC,OAAO;MACLO,EAAE,EAAE,IAAAC,kBAAU,EAAC,CAAC;MAChB,GAAGF,QAAQ;MACX,GAAGP;IACL,CAAC;EACH,CAAC;EAED;AACF;AACA;EACEU,SAAS,EAAE,SAAAA,CACTX,IAAO,EACPY,KAAa,EACbX,UAAmC,GAAG,CAAC,CAAC,EACxCC,YAAoC,GAAG,CAAC,CAAC,EACZ;IAC7B,MAAMW,SAAsC,GAAG,EAAE;IACjD,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,KAAK,EAAEE,CAAC,EAAE,EAAE;MAC9BD,SAAS,CAACE,IAAI,CAAC,IAAI,CAAChB,KAAK,CAACC,IAAI,EAAEC,UAAU,EAAEC,YAAY,CAAC,CAAC;IAC5D;IACA,OAAOW,SAAS;EAClB;AACF,CAAC","ignoreList":[]}

package/dist/factory/factory.types.d.ts

@@ -0,0 +1,38 @@
+import { ConnectionModel, ConnectionBuildOptions, OrganizationModel, UserModel, UserBuildOptions } from './workers';
+type FactoryTyping = {
+    /** Mapping for the connection model */
+    connection: {
+        /** Options for the connection model */
+        options: ConnectionBuildOptions;
+        /** Return type for the connection model */
+        return: ConnectionModel;
+    };
+    /** Mapping for the organization model */
+    organization: {
+        /** Options for the organization model */
+        options: any;
+        /** Return type for the organization model */
+        return: OrganizationModel;
+    };
+    /** Mapping for the user model */
+    user: {
+        /** Options for the user model */
+        options: UserBuildOptions;
+        /** Return type for the user model */
+        return: UserModel;
+    };
+};
+export type FactoryModel = keyof FactoryTyping;
+export type FactoryModelOverride<T extends FactoryModel> = Partial<FactoryTyping[T]['return']> & {
+    /** Id of the model */
+    id?: string;
+};
+export type FactoryBuildOptions<T extends FactoryModel> = FactoryTyping[T]['options'];
+export type FactoryReturnType<T extends FactoryModel> = FactoryTyping[T]['return'] & {
+    /** Id of the model */
+    id: string;
+};
+export type ModelsMap = {
+    [T in FactoryModel]: (buildOptions: FactoryTyping[T]['options']) => FactoryTyping[T]['return'];
+};
+export {};

package/dist/factory/factory.types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=factory.types.js.map

package/dist/factory/factory.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.types.js","names":[],"sources":["../../src/factory/factory.types.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  ConnectionModel,\n  ConnectionBuildOptions,\n  OrganizationModel,\n  UserModel,\n  UserBuildOptions,\n} from './workers';\n\ntype FactoryTyping = {\n  /** Mapping for the connection model */\n  connection: {\n    /** Options for the connection model */\n    options: ConnectionBuildOptions;\n    /** Return type for the connection model */\n    return: ConnectionModel;\n  };\n  /** Mapping for the organization model */\n  organization: {\n    /** Options for the organization model */\n    options: any;\n    /** Return type for the organization model */\n    return: OrganizationModel;\n  };\n  /** Mapping for the user model */\n  user: {\n    /** Options for the user model */\n    options: UserBuildOptions;\n    /** Return type for the user model */\n    return: UserModel;\n  };\n};\n\nexport type FactoryModel = keyof FactoryTyping;\n\nexport type FactoryModelOverride<T extends FactoryModel> = Partial<FactoryTyping[T]['return']> & {\n  /** Id of the model */\n  id?: string;\n};\n\nexport type FactoryBuildOptions<T extends FactoryModel> = FactoryTyping[T]['options'];\n\nexport type FactoryReturnType<T extends FactoryModel> = FactoryTyping[T]['return'] & {\n  /** Id of the model */\n  id: string;\n};\n\nexport type ModelsMap = {\n  [T in FactoryModel]: (buildOptions: FactoryTyping[T]['options']) => FactoryTyping[T]['return'];\n};\n"],"mappings":"","ignoreList":[]}

package/dist/factory/index.d.ts

@@ -0,0 +1,2 @@
+export * from './workers';
+export * from './factory';

package/dist/factory/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _workers = require("./workers");
+Object.keys(_workers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _workers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _workers[key];
+    }
+  });
+});
+var _factory = require("./factory");
+Object.keys(_factory).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _factory[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _factory[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/dist/factory/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_workers","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_factory"],"sources":["../../src/factory/index.ts"],"sourcesContent":["export * from './workers';\nexport * from './factory';\n"],"mappings":";;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,QAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,QAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,QAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,QAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,QAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,QAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,QAAA,CAAAL,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/dist/factory/workers/connection.d.ts

@@ -0,0 +1,3 @@
+import { ConnectionBuildOptions, ConnectionModel } from './connection.types';
+/** Create a random connection */
+export declare function connectionFactoryWorker(buildOptions?: ConnectionBuildOptions): ConnectionModel;

package/dist/factory/workers/connection.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.connectionFactoryWorker = connectionFactoryWorker;
+var _crypto = require("crypto");
+var _faker = require("@faker-js/faker");
+/** Create a random connection */
+function connectionFactoryWorker(buildOptions = {}) {
+  const accepted = buildOptions.accepted ?? true;
+  const blocked = buildOptions.blocked ?? false;
+  return {
+    ownerId: (0, _crypto.randomUUID)(),
+    otherUserId: (0, _crypto.randomUUID)(),
+    accepted,
+    acceptedAt: accepted ? _faker.faker.date.recent() : undefined,
+    blocked,
+    blockedAt: blocked ? _faker.faker.date.recent() : undefined,
+    initiator: true,
+    message: _faker.faker.lorem.sentence(),
+    note: _faker.faker.lorem.sentence()
+  };
+}
+//# sourceMappingURL=connection.js.map

package/dist/factory/workers/connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.js","names":["_crypto","require","_faker","connectionFactoryWorker","buildOptions","accepted","blocked","ownerId","randomUUID","otherUserId","acceptedAt","faker","date","recent","undefined","blockedAt","initiator","message","lorem","sentence","note"],"sources":["../../../src/factory/workers/connection.ts"],"sourcesContent":["import {randomUUID} from 'crypto';\nimport { faker } from '@faker-js/faker';\nimport {ConnectionBuildOptions, ConnectionModel} from './connection.types';\n\n/** Create a random connection */\nexport function connectionFactoryWorker(\n  buildOptions: ConnectionBuildOptions = {},\n): ConnectionModel {\n  const accepted = buildOptions.accepted ?? true;\n  const blocked = buildOptions.blocked ?? false;\n  return {\n    ownerId: randomUUID(),\n    otherUserId: randomUUID(),\n    accepted,\n    acceptedAt: accepted ? faker.date.recent() : undefined,\n    blocked,\n    blockedAt: blocked ? faker.date.recent() : undefined,\n    initiator: true,\n    message: faker.lorem.sentence(),\n    note: faker.lorem.sentence(),\n  };\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAGA;AACO,SAASE,uBAAuBA,CACrCC,YAAoC,GAAG,CAAC,CAAC,EACxB;EACjB,MAAMC,QAAQ,GAAGD,YAAY,CAACC,QAAQ,IAAI,IAAI;EAC9C,MAAMC,OAAO,GAAGF,YAAY,CAACE,OAAO,IAAI,KAAK;EAC7C,OAAO;IACLC,OAAO,EAAE,IAAAC,kBAAU,EAAC,CAAC;IACrBC,WAAW,EAAE,IAAAD,kBAAU,EAAC,CAAC;IACzBH,QAAQ;IACRK,UAAU,EAAEL,QAAQ,GAAGM,YAAK,CAACC,IAAI,CAACC,MAAM,CAAC,CAAC,GAAGC,SAAS;IACtDR,OAAO;IACPS,SAAS,EAAET,OAAO,GAAGK,YAAK,CAACC,IAAI,CAACC,MAAM,CAAC,CAAC,GAAGC,SAAS;IACpDE,SAAS,EAAE,IAAI;IACfC,OAAO,EAAEN,YAAK,CAACO,KAAK,CAACC,QAAQ,CAAC,CAAC;IAC/BC,IAAI,EAAET,YAAK,CAACO,KAAK,CAACC,QAAQ,CAAC;EAC7B,CAAC;AACH","ignoreList":[]}

package/dist/factory/workers/connection.types.d.ts

@@ -0,0 +1,28 @@
+/** Connection base model */
+export interface ConnectionModel {
+    /** Owner of the connection */
+    ownerId: string;
+    /** USer with which the owner is connected */
+    otherUserId: string;
+    /** Wether the connection is accepted or not */
+    accepted: boolean;
+    /** Date at which the connection was accepted */
+    acceptedAt?: Date;
+    /** Wether the owner did block the other user */
+    blocked: boolean;
+    /** Date at which the connection was blocked */
+    blockedAt?: Date;
+    /** Did the owner initiate the connection */
+    initiator: boolean;
+    /** Message sent to the other user with the connection */
+    message: string;
+    /** Private note the user has on the connection */
+    note: string;
+}
+/** Build options for connections */
+export interface ConnectionBuildOptions {
+    /** Wether the connection is accepted or not */
+    accepted?: boolean;
+    /** Wether the owner did block the other user */
+    blocked?: boolean;
+}

package/dist/factory/workers/connection.types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=connection.types.js.map

package/dist/factory/workers/connection.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.types.js","names":[],"sources":["../../../src/factory/workers/connection.types.ts"],"sourcesContent":["/** Connection base model */\nexport interface ConnectionModel {\n  /** Owner of the connection */\n  ownerId: string;\n  /** USer with which the owner is connected */\n  otherUserId: string;\n  /** Wether the connection is accepted or not */\n  accepted: boolean;\n  /** Date at which the connection was accepted */\n  acceptedAt?: Date;\n  /** Wether the owner did block the other user */\n  blocked: boolean;\n  /** Date at which the connection was blocked */\n  blockedAt?: Date;\n  /** Did the owner initiate the connection */\n  initiator: boolean;\n  /** Message sent to the other user with the connection */\n  message: string;\n  /** Private note the user has on the connection */\n  note: string;\n}\n\n/** Build options for connections */\nexport interface ConnectionBuildOptions {\n  /** Wether the connection is accepted or not */\n  accepted?: boolean;\n  /** Wether the owner did block the other user */\n  blocked?: boolean;\n}\n"],"mappings":"","ignoreList":[]}

package/dist/factory/workers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './user';
+export * from './user.types';
+export * from './connection';
+export * from './connection.types';
+export * from './organization';
+export * from './organization.types';

package/dist/factory/workers/index.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _user = require("./user");
+Object.keys(_user).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _user[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _user[key];
+    }
+  });
+});
+var _user2 = require("./user.types");
+Object.keys(_user2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _user2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _user2[key];
+    }
+  });
+});
+var _connection = require("./connection");
+Object.keys(_connection).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _connection[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _connection[key];
+    }
+  });
+});
+var _connection2 = require("./connection.types");
+Object.keys(_connection2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _connection2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _connection2[key];
+    }
+  });
+});
+var _organization = require("./organization");
+Object.keys(_organization).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _organization[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _organization[key];
+    }
+  });
+});
+var _organization2 = require("./organization.types");
+Object.keys(_organization2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _organization2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _organization2[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map