Typescript Repository

a Basic Repository Contract to implement your custom Repository.

Install

npm install --save @apihub24/ts-repository

Usage

implement the IRepository interface to use the Repository for example in Memory.

import {
  IConnectedCondition,
  IQuery,
  OrderDirection,
  SortSettings,
  Repository,
} from "@apihub24/ts_repository";

class TestRight {
  id?: string;
  name = "";
}
class TestGroup {
  id?: string;
  name = "";
  rights = new Array<TestRight>();
}
class TestUser {
  id?: string;
  userName = "";
  age = 0;
  group?: TestGroup;
}

class TestInMemoryRepository<T extends { id?: string }>
  implements Repository<T>
{
  source = new Array<T>();

  async get(query: IQuery<T>): Promise<T[]> {
    const result = new Array<T>();
    let row = -1;
    for (const ds of query.order ? this.sortArray(query.order) : this.source) {
      row++;
      if (query.skip && query.skip > row) {
        continue;
      }
      if (query.limit && result.length >= query.limit) {
        break;
      }
      let take = true;
      for (const cond of query.conditions ?? []) {
        const dsValue = ds[cond.name];
        switch (cond.operator) {
          case "eq":
            take = dsValue === cond.value;
            break;
          case "neq":
            take = dsValue !== cond.value;
            break;
          case "gt":
            take = dsValue > cond.value;
            break;
          case "gte":
            take = dsValue >= cond.value;
            break;
          case "lt":
            take = dsValue < cond.value;
            break;
          case "lte":
            take = dsValue <= cond.value;
            break;
          case "in":
            take = cond.value.includes(dsValue);
            break;
          case "nin":
            take = !cond.value.includes(dsValue);
            break;
          default:
            continue;
        }
        if (!take && cond.connector === "and") {
          break;
        }
      }
      if (!take) {
        continue;
      }
      result.push(ds);
    }
    return Promise.resolve(result);
  }

  async save(data: T): Promise<T> {
    if (!data.id) {
      data.id = crypto.randomUUID();
    }
    if (!this.source.find((d) => d.id === data.id)) {
      this.source.push(data);
    }
    const result = this.source.find((d) => d.id === data.id);
    if (!result) {
      throw new Error(`dataset not saved correctly`);
    }
    return Promise.resolve(result);
  }

  async delete(conditions: IConnectedCondition<T>[]): Promise<boolean> {
    const deletions = await this.get({
      conditions,
      limit: 0,
      skip: 0,
      order: [],
    });
    for (const del of deletions) {
      this.source = this.source.filter((d) => d.id !== del.id);
    }
    return Promise.resolve(true);
  }

  async clear() {
    this.source = [];
  }

  private sortArray(sortSettings: SortSettings<T>): T[] {
    const sortedData = [...this.source];

    sortedData.sort((a, b) => {
      for (const setting of sortSettings) {
        const key = Object.keys(setting)[0] as keyof T;
        const direction = Object.values(setting)[0] as OrderDirection;

        const aValue = a[key];
        const bValue = b[key];

        if (aValue === bValue) {
          continue;
        }

        if (direction === "asc") {
          if (aValue < bValue) {
            return -1;
          }
          if (aValue > bValue) {
            return 1;
          }
        } else {
          if (aValue < bValue) {
            return 1;
          }
          if (aValue > bValue) {
            return -1;
          }
        }
      }
      return 0;
    });

    return sortedData;
  }
}