feat(datasource-replica): add replica datasource

.github/workflows/build.yml

@@ -65,6 +65,7 @@ jobs:
           - datasource-customizer
           - datasource-dummy
           - datasource-mongoose
+          - datasource-replica
           - datasource-sequelize
           - datasource-sql
           - datasource-toolkit
@@ -126,6 +127,7 @@ jobs:
             ${{github.workspace}}/reports/datasource-customizer/clover.xml:clover
             ${{github.workspace}}/reports/datasource-dummy/clover.xml:clover
             ${{github.workspace}}/reports/datasource-mongoose/clover.xml:clover
+            ${{github.workspace}}/reports/datasource-replica/clover.xml:clover
             ${{github.workspace}}/reports/datasource-sequelize/clover.xml:clover
             ${{github.workspace}}/reports/datasource-sql/clover.xml:clover
             ${{github.workspace}}/reports/datasource-toolkit/clover.xml:clover

.gitignore

@@ -1,3 +1,4 @@
+*.sqlite
 .DS_Store
 coverage
 dist

packages/_example/package.json

@@ -45,4 +45,4 @@
   "devDependencies": {
     "nodemon": "^2.0.20"
   }
-}
+}

packages/datasource-customizer/src/decorators/actions/context/base.ts

@@ -3,6 +3,7 @@ import {
   Caller,
   Collection,
   CompositeId,
+  Deferred,
   Projection,
   ProjectionValidator,
   RecordData,
@@ -12,19 +13,6 @@ import {
 import CollectionCustomizationContext from '../../../context/collection-context';
 import { TCollectionName, TFieldName, TFilter, TRow, TSchema } from '../../../templates';
 
-class Deferred<T> {
-  promise: Promise<T>;
-  resolve: (result: T) => void;
-  reject: (error: Error) => void;
-
-  constructor() {
-    this.promise = new Promise((resolve, reject) => {
-      this.reject = reject;
-      this.resolve = resolve;
-    });
-  }
-}
-
 export default class ActionContext<
   S extends TSchema = TSchema,
   N extends TCollectionName<S> = TCollectionName<S>,

packages/datasource-replica/jest.config.ts

@@ -0,0 +1,8 @@
+/* eslint-disable import/no-relative-packages */
+import jestConfig from '../../jest.config';
+
+export default {
+  ...jestConfig,
+  collectCoverageFrom: ['<rootDir>/src/**/*.ts'],
+  testMatch: ['<rootDir>/test/**/*.test.ts'],
+};

packages/datasource-replica/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@forestadmin/datasource-replica",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "license": "GPL-3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ForestAdmin/agent-nodejs.git",
+    "directory": "packages/datasource-replica"
+  },
+  "files": [
+    "dist/src/**/*.js",
+    "dist/src/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "clean": "rm -rf coverage dist",
+    "lint": "eslint src test",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@forestadmin/datasource-customizer": "^1.9.1",
+    "@forestadmin/datasource-sequelize": "^1.3.1",
+    "@forestadmin/datasource-sql": "1.7.0",
+    "@forestadmin/datasource-toolkit": "^1.5.0",
+    "croner": "^6.0.6",
+    "sequelize": "^6.28.0"
+  }
+}

packages/datasource-replica/src/cache-interface/collection.ts

@@ -0,0 +1,123 @@
+import {
+  TAggregateResult,
+  TAggregation,
+  TFilter,
+  TPaginatedFilter,
+  TRow,
+} from '@forestadmin/datasource-customizer';
+import {
+  Aggregation,
+  Caller,
+  Collection,
+  ConditionTreeFactory,
+  Filter,
+  Page,
+  PaginatedFilter,
+  Projection,
+  Sort,
+} from '@forestadmin/datasource-toolkit';
+
+export default class CacheCollectionInterface {
+  private collection: Collection;
+  private caller: Caller;
+
+  constructor(collection: Collection, caller: Caller) {
+    this.caller = caller;
+    this.collection = collection;
+  }
+
+  /**
+   * List multiple records
+   * @param filter the filter used to select the records to list
+   * @param projection an array of fields name representing the data to select
+   * @example
+   * .list({
+   *    conditionTree: {
+   *      aggregator: 'And',
+   *      conditions: [{
+   *        field: 'amountInEur',
+   *        operator: 'GreaterThan',
+   *        value: 1000
+   *      }, {
+   *        field: 'description',
+   *        operator: 'Contains',
+   *        value: 'Refund',
+   *      }],
+   *      page: { limit: 10, skip: 0 },
+   *      sort: [{ field: 'id', ascending: true }]
+   *   }
+   * }, ['id', 'amountInEur', 'description']);
+   */
+  list(filter: TPaginatedFilter, projection: string[]): Promise<TRow[]> {
+    const filterInstance = this.buildPaginatedFilter(filter);
+    const projectionInstance = this.buildProjection(projection);
+    const rows = this.collection.list(this.caller, filterInstance, projectionInstance);
+
+    return rows as Promise<TRow[]>;
+  }
+
+  /**
+   * Aggregate a list of records
+   * @param filter the filter used to list the records to aggregate
+   * @param aggregation the aggregation to apply
+   * @param limit the maximum number of result to return
+   * @example
+   * .aggregate({
+   *    conditionTree: {
+   *      field: "user:company:id",
+   *      operator: "In",
+   *      value: records.map((r) => r.id),
+   *    },
+   * }, {
+   *    operation: "Sum",
+   *    field: "amountInEur",
+   *    groups: [{ field: "user:company:id" }],
+   * }, 10);
+   */
+  async aggregate(
+    filter: TFilter,
+    aggregation: TAggregation,
+    limit?: number,
+  ): Promise<TAggregateResult[]> {
+    const filterInstance = this.buildFilter(filter);
+    const aggregationInstance = this.buildAggregation(aggregation);
+    const result = await this.collection.aggregate(
+      this.caller,
+      filterInstance,
+      aggregationInstance,
+      limit,
+    );
+
+    return result as TAggregateResult[];
+  }
+
+  private buildFilter(filter: TFilter): Filter {
+    return filter
+      ? new Filter({
+          ...filter,
+          conditionTree: filter.conditionTree
+            ? ConditionTreeFactory.fromPlainObject(filter.conditionTree)
+            : undefined,
+        })
+      : null;
+  }
+
+  private buildPaginatedFilter(filter: TPaginatedFilter): PaginatedFilter {
+    return new PaginatedFilter({
+      ...filter,
+      conditionTree: filter?.conditionTree
+        ? ConditionTreeFactory.fromPlainObject(filter.conditionTree)
+        : undefined,
+      sort: filter.sort ? new Sort(...filter.sort) : undefined,
+      page: filter.page ? new Page(filter.page.skip, filter.page.limit) : undefined,
+    });
+  }
+
+  private buildProjection(projection: string[]): Projection {
+    return new Projection(...projection);
+  }
+
+  private buildAggregation(aggregation: TAggregation): Aggregation {
+    return new Aggregation(aggregation);
+  }
+}

packages/datasource-replica/src/cache-interface/datasource.ts

@@ -0,0 +1,32 @@
+import type { Caller, DataSource } from '@forestadmin/datasource-toolkit';
+
+import CacheCollectionInterface from './collection';
+
+/** DataSource wrapper which accepts plain objects in all methods */
+export default class CacheDataSourceInterface {
+  private dataSource: DataSource;
+  private caller: Caller = {
+    id: 0,
+    email: 'datasource-replica@forestadmin.com',
+    firstName: 'Datasource',
+    lastName: 'Replica',
+    renderingId: 0,
+    role: 'system',
+    tags: {},
+    team: 'system',
+    timezone: 'UTC',
+    requestId: '',
+  };
+
+  constructor(dataSource: DataSource) {
+    this.dataSource = dataSource;
+  }
+
+  /**
+   * Get a collection from a datasource
+   * @param name the name of the collection
+   */
+  getCollection(name: string): CacheCollectionInterface {
+    return new CacheCollectionInterface(this.dataSource.getCollection(name), this.caller);
+  }
+}

packages/datasource-replica/src/decorators/schema/collection.ts

@@ -0,0 +1,42 @@
+import { CollectionDecorator, CollectionSchema, ColumnType } from '@forestadmin/datasource-toolkit';
+
+import SchemaDataSourceDecorator from './data-source';
+import { Field, LeafField, isLeafField } from '../../types';
+
+export default class SchemaCollectionDecorator extends CollectionDecorator {
+  override dataSource: SchemaDataSourceDecorator;
+
+  protected override refineSchema(subSchema: CollectionSchema): CollectionSchema {
+    const baseFields = this.dataSource.getFields(this.name);
+    const newSchema = { ...subSchema, fields: { ...subSchema.fields } };
+
+    for (const [key, field] of Object.entries(newSchema.fields)) {
+      if (field.type === 'Column') {
+        const baseField = baseFields[key] as LeafField;
+        newSchema.fields[key] = {
+          ...field,
+          columnType: this.computeType(baseField),
+          isReadOnly: baseField.isReadOnly,
+          defaultValue: baseField.defaultValue,
+          validation: baseField.validation,
+        };
+      }
+    }
+
+    return newSchema;
+  }
+
+  private computeType(field: Field): ColumnType {
+    if (isLeafField(field)) {
+      return field.type === 'Integer' ? 'Number' : field.type;
+    }
+
+    if (Array.isArray(field)) {
+      return [this.computeType(field[0])];
+    }
+
+    const entries = Object.entries(field).map(([key, value]) => [key, this.computeType(value)]);
+
+    return Object.fromEntries(entries);
+  }
+}

packages/datasource-replica/src/decorators/schema/data-source.ts

@@ -0,0 +1,18 @@
+import { DataSource, DataSourceDecorator } from '@forestadmin/datasource-toolkit';
+
+import SchemaCollectionDecorator from './collection';
+import { CollectionReplicaSchema, ResolvedOptions } from '../../types';
+
+export default class SchemaDataSourceDecorator extends DataSourceDecorator<SchemaCollectionDecorator> {
+  private readonly flatSchema: CollectionReplicaSchema[];
+
+  constructor(childDataSource: DataSource, options: ResolvedOptions) {
+    super(childDataSource, SchemaCollectionDecorator);
+
+    this.flatSchema = options.flattenSchema;
+  }
+
+  getFields(name: string): CollectionReplicaSchema['fields'] {
+    return this.flatSchema.find(c => c.name === name).fields;
+  }
+}