refactor(json-api-nestjs): move to project

use as separete package in next version

Author: klerick

libs/json-api/json-api-nestjs-sdk/src/shared/index.ts

@@ -0,0 +1,2 @@
+export * from './lib/utils';
+export * from './lib/types';

libs/json-api/json-api-nestjs-sdk/src/shared/lib/types/entity-type.ts

@@ -0,0 +1,17 @@
+export type EntityField =
+  | string
+  | number
+  | bigint
+  | boolean
+  | string[]
+  | number[]
+  | null
+  | Date;
+
+export type EntityProps<T> = {
+  [P in keyof T]: T[P] extends EntityField ? P : never;
+}[keyof T];
+
+export type EntityRelation<T> = {
+  [P in keyof T]: T[P] extends EntityField ? never : P;
+}[keyof T];

libs/json-api/json-api-nestjs-sdk/src/shared/lib/types/index.ts

@@ -0,0 +1,4 @@
+export * from './utils-string.type';
+export * from './query-type';
+export * from './entity-type';
+export * from './response-body';

libs/json-api/json-api-nestjs-sdk/src/shared/lib/types/query-type.ts

@@ -0,0 +1,36 @@
+export enum QueryField {
+  filter = 'filter',
+  sort = 'sort',
+  include = 'include',
+  page = 'page',
+  fields = 'fields',
+}
+
+export enum FilterOperand {
+  eq = 'eq',
+  gt = 'gt',
+  gte = 'gte',
+  like = 'like',
+  lt = 'lt',
+  lte = 'lte',
+  ne = 'ne',
+  regexp = 'regexp',
+  in = 'in',
+  nin = 'nin',
+  some = 'some',
+}
+
+export enum FilterOperandOnlyInNin {
+  in = 'in',
+  nin = 'nin',
+}
+export enum FilterOperandOnlySimple {
+  eq = 'eq',
+  gt = 'gt',
+  gte = 'gte',
+  like = 'like',
+  lt = 'lt',
+  lte = 'lte',
+  ne = 'ne',
+  regexp = 'regexp',
+}

libs/json-api/json-api-nestjs-sdk/src/shared/lib/types/response-body.ts

@@ -0,0 +1,76 @@
+import {
+  EntityField,
+  EntityProps,
+  EntityRelation,
+  TypeOfArray,
+  ValueOf,
+} from '.';
+import { Collection } from '@mikro-orm/core';
+
+export type PageProps = {
+  totalItems: number;
+  pageNumber: number;
+  pageSize: number;
+};
+
+export type DebugMetaProps = Partial<{
+  time: number;
+}>;
+
+export type MainData<T = string> = {
+  type: T;
+  id: string;
+};
+
+export type Links = {
+  self: string;
+  related?: string;
+};
+
+export type Attributes<D> = {
+  [P in EntityProps<D>]?: D[P] extends EntityField ? D[P] : TypeOfArray<D[P]>;
+};
+
+export type DataResult<E, S = string> = E extends unknown[]
+  ? MainData<S>[]
+  : E extends Collection<any>
+  ? MainData<S>[]
+  : MainData<S> | null;
+
+export type Data<E, S = string> = {
+  data?: DataResult<E, S>;
+};
+
+export type Relationships<T> = {
+  [P in EntityRelation<T>]?: {
+    links: Links;
+  } & Data<T[P], P>;
+};
+
+export type Include<T> = ValueOf<{
+  [P in EntityRelation<T>]: ResourceData<TypeOfArray<T[P]>>;
+}>;
+
+export type ResourceData<T> = MainData & {
+  attributes?: Attributes<T>;
+  relationships?: Relationships<T>;
+  links: Omit<Links, 'related'>;
+};
+
+export type MetaProps<T, R = null> = R extends null ? T : T & R;
+
+export type ResourceObject<
+  T,
+  R extends 'object' | 'array' = 'object',
+  M = null
+> = {
+  meta: R extends 'array'
+    ? MetaProps<PageProps & DebugMetaProps, M>
+    : MetaProps<DebugMetaProps, M>;
+  data: R extends 'array' ? ResourceData<T>[] : ResourceData<T>;
+  included?: Include<T>[];
+};
+
+export type ResourceObjectRelationships<E, K extends EntityRelation<E>> = {
+  meta: DebugMetaProps;
+} & Required<Data<E[K], K>>;

libs/json-api/json-api-nestjs-sdk/src/shared/lib/types/utils-string.type.ts

@@ -0,0 +1,26 @@
+import type { Collection } from '@mikro-orm/core';
+
+export type KebabCase<S> = S extends `${infer C}${infer T}`
+  ? KebabCase<T> extends infer U
+    ? U extends string
+      ? T extends Uncapitalize<T>
+        ? `${Uncapitalize<C>}${U}`
+        : `${Uncapitalize<C>}-${U}`
+      : never
+    : never
+  : S;
+
+export type KebabToCamelCase<S extends string> =
+  S extends `${infer T}-${infer U}-${infer V}`
+    ? `${T}${Capitalize<U>}${Capitalize<KebabToCamelCase<V>>}`
+    : S extends `${infer T}-${infer U}`
+    ? `${Capitalize<T>}${Capitalize<KebabToCamelCase<U>>}`
+    : S;
+
+export type TypeOfArray<T> = T extends (infer U)[]
+  ? U
+  : T extends Collection<infer U>
+  ? U
+  : T;
+
+export type ValueOf<T> = T[keyof T];

libs/json-api/json-api-nestjs-sdk/src/shared/lib/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './string-utils';
+export * from './object-utils';

libs/json-api/json-api-nestjs-sdk/src/shared/lib/utils/object-utils.ts

@@ -0,0 +1,21 @@
+import { kebabToCamel } from './string-utils';
+
+export const ObjectTyped = {
+  keys: Object.keys as <T extends {}>(yourObject: T) => Array<keyof T>,
+  values: Object.values as <U extends {}>(yourObject: U) => Array<U[keyof U]>,
+  entries: Object.entries as <O extends {}>(
+    yourObject: O
+  ) => Array<[keyof O, O[keyof O]]>,
+  fromEntries: Object.fromEntries as <K extends string, V>(
+    yourObjectEntries: [K, V][]
+  ) => Record<K, V>,
+};
+
+export function isObject(item: unknown): item is object {
+  return typeof item === 'object' && !Array.isArray(item) && item !== null;
+}
+
+export function createEntityInstance<E>(name: string): E {
+  const entityName = kebabToCamel(name);
+  return Function('return new class ' + entityName + '{}')();
+}

libs/json-api/json-api-nestjs-sdk/src/shared/lib/utils/string-utils.spec.ts

@@ -0,0 +1,42 @@
+import {
+  camelToKebab,
+  snakeToCamel,
+  isString,
+  kebabToCamel,
+} from './string-utils';
+
+describe('Test utils', () => {
+  it('camelToKebab', () => {
+    const result = camelToKebab('ApproverGroups');
+    const result1 = camelToKebab('Users');
+
+    expect(result).toBe('approver-groups');
+    expect(result1).toBe('users');
+  });
+
+  it('snakeToCamel', () => {
+    const result = snakeToCamel('test_test');
+    const result1 = snakeToCamel('test-test');
+    const result2 = snakeToCamel('testTest');
+    const result3 = snakeToCamel('event_incident_typeFK');
+    expect(result).toBe('testTest');
+    expect(result1).toBe('testTest');
+    expect(result2).toBe('testTest');
+    expect(result3).toBe('eventIncidentTypeFK');
+  });
+
+  it('isString', () => {
+    expect(isString('string')).toBe(true);
+    expect(isString(String('string'))).toBe(true);
+    expect(isString(new Date())).toBe(false);
+    expect(isString(class {})).toBe(false);
+  });
+
+  it('kebabToCamel', () => {
+    const type = 'users-group';
+    const type1 = 'users';
+
+    expect(kebabToCamel(type)).toBe('UsersGroup');
+    expect(kebabToCamel(type1)).toBe('Users');
+  });
+});

libs/json-api/json-api-nestjs-sdk/src/shared/lib/utils/string-utils.ts

@@ -0,0 +1,38 @@
+import { KebabToCamelCase, KebabCase } from '../types';
+
+export function isString<T, P extends T>(value: T): value is P {
+  return typeof value === 'string' || value instanceof String;
+}
+
+export function snakeToCamel(str: string): string {
+  if (!str.match(/[\s_-]/g)) {
+    return str;
+  }
+  return str.replace(/([-_][a-z])/g, (group) =>
+    group.toUpperCase().replace('-', '').replace('_', '')
+  );
+}
+
+export function camelToKebab<S extends string>(string: S): KebabCase<S> {
+  return string
+    .replace(/((?<=[a-z\d])[A-Z]|(?<=[A-Z\d])[A-Z](?=[a-z]))/g, '-$1')
+    .toLowerCase() as KebabCase<S>;
+}
+
+export function upperFirstLetter<S extends string>(string: S): Capitalize<S> {
+  return (string.charAt(0).toUpperCase() + string.slice(1)) as Capitalize<S>;
+}
+
+export function kebabToCamel<S extends string>(str: S): KebabToCamelCase<S> {
+  return str
+    .split('-')
+    .map((i) => i.charAt(0).toUpperCase() + i.substring(1))
+    .join('') as KebabToCamelCase<S>;
+}
+
+export function capitalizeFirstChar(str: string) {
+  return str
+    .split('-')
+    .map((i) => i.charAt(0).toUpperCase() + i.substring(1))
+    .join('');
+}