feat: enhance typing with interfaces and lesser coupling

packages/codec-url-simple/src/decoder/module.ts

@@ -13,11 +13,12 @@ import {
 } from '@rapiq/parser-simple';
 import { parse } from 'qs';
 import type {
-    Condition,
-    Fields,
-    Pagination,
-    Relations,
-    Sorts,
+    IFields,
+    IFilters,
+    IPagination,
+    IQuery,
+    IRelations,
+    ISorts,
 } from '@rapiq/core';
 import {
     Query,
@@ -44,7 +45,7 @@ export class URLDecoder {
         this.sort = new SimpleSortParser();
     }
 
-    decode(input: string) : Query | null {
+    decode(input: string) : IQuery | null {
         const parsed = parse(input);
         if (!isObject(parsed)) {
             return null;
@@ -75,7 +76,7 @@ export class URLDecoder {
         return output;
     }
 
-    decodeFields(input: string) : Fields | null {
+    decodeFields(input: string) : IFields | null {
         const output = parse(input);
         if (!isObject(output)) {
             return null;
@@ -88,41 +89,33 @@ export class URLDecoder {
         return this.fields.parse(output);
     }
 
-    decodeFilters(input: string) : Condition | null {
+    decodeFilters(input: string) : IFilters | null {
         const output = parse(input);
         if (!isObject(output)) {
             return null;
         }
 
         if (output[URLParameter.FILTERS]) {
-            if (isObject(output[URLParameter.FILTERS])) {
-                return this.filters.parse(output[URLParameter.FILTERS]);
-            }
-
-            return null;
+            return this.filters.parse(output[URLParameter.FILTERS]);
         }
 
         return this.filters.parse(output);
     }
 
-    decodePagination(input: string) : Pagination | null {
+    decodePagination(input: string) : IPagination | null {
         const output = parse(input);
         if (!isObject(output)) {
             return null;
         }
 
         if (output[URLParameter.PAGINATION]) {
-            if (isObject(output[URLParameter.PAGINATION])) {
-                return this.pagination.parse(output[URLParameter.PAGINATION]);
-            }
-
-            return null;
+            return this.pagination.parse(output[URLParameter.PAGINATION]);
         }
 
         return this.pagination.parse(output);
     }
 
-    decodeRelations(input: string) : Relations | null {
+    decodeRelations(input: string) : IRelations | null {
         const output = parse(input);
         if (!isObject(output)) {
             return null;
@@ -135,7 +128,7 @@ export class URLDecoder {
         return this.relations.parse(output);
     }
 
-    decodeSort(input: string) : Sorts | null {
+    decodeSort(input: string) : ISorts | null {
         const output = parse(input);
         if (!isObject(output)) {
             return null;

packages/codec-url-simple/src/encoder/module.ts

@@ -6,11 +6,14 @@
  */
 
 import type {
-    Field,
-    Fields,
-    Filter,
-    Filters, Pagination,
-    Query, Relations, Sorts,
+    IField,
+    IFields,
+    IFilter,
+    IFilters,
+    IPagination,
+    IQuery,
+    IRelations,
+    ISorts,
 } from '@rapiq/core';
 import type { IEncoder } from '../types';
 import type { ISerializer } from './serializer';
@@ -23,35 +26,35 @@ export class URLEncoder implements IEncoder<string | null> {
         this.visitor = new QueryVisitor();
     }
 
-    encode(input: Query): string | null {
+    encode(input: IQuery): string | null {
         return this.runSerializer(this.visitor.visitQuery(input));
     }
 
-    encodeFields(input: Fields) {
+    encodeFields(input: IFields) {
         return this.runSerializer(this.visitor.visitFields(input));
     }
 
-    encodeField(input: Field) {
+    encodeField(input: IField) {
         return this.runSerializer(this.visitor.visitField(input));
     }
 
-    encodeFilters(input: Filters) {
+    encodeFilters(input: IFilters) {
         return this.runSerializer(this.visitor.visitFilters(input));
     }
 
-    encodeFilter(input: Filter) {
+    encodeFilter(input: IFilter) {
         return this.runSerializer(this.visitor.visitFilter(input));
     }
 
-    encodePagination(input: Pagination) {
+    encodePagination(input: IPagination) {
         return this.runSerializer(this.visitor.visitPagination(input));
     }
 
-    encodeRelations(input: Relations) {
+    encodeRelations(input: IRelations) {
         return this.runSerializer(this.visitor.visitRelations(input));
     }
 
-    encodeSort(input: Sorts) {
+    encodeSort(input: ISorts) {
         return this.runSerializer(this.visitor.visitSorts(input));
     }
 

packages/codec-url-simple/src/encoder/visitors/module.ts

@@ -6,25 +6,26 @@
  */
 
 import type {
-    Field,
-    Fields,
-    Filter,
-    Filters,
+    IField,
     IFieldVisitor,
+    IFields,
     IFieldsVisitor,
+    IFilter,
     IFilterVisitor,
+    IFilters,
     IFiltersVisitor,
+    IPagination,
     IPaginationVisitor,
+    IQuery,
     IQueryVisitor,
+    IRelation,
     IRelationVisitor,
+    IRelations,
     IRelationsVisitor,
+    ISort,
     ISortVisitor,
+    ISorts,
     ISortsVisitor,
-    Pagination,
-    Query,
-    Relation,
-    Relations,
-    Sort, Sorts,
 } from '@rapiq/core';
 import type { ArraySerializer, RecordArraySerializer, RecordSerializer } from '../serializer';
 import { QuerySerializer } from '../serializer';
@@ -68,7 +69,7 @@ export class QueryVisitor implements IQueryVisitor<QuerySerializer>,
         this.sort = new SortsVisitor(serializer.sort);
     }
 
-    visitQuery(expr: Query): QuerySerializer {
+    visitQuery(expr: IQuery): QuerySerializer {
         if (expr.fields) {
             expr.fields.accept(this.fields);
         }
@@ -92,39 +93,39 @@ export class QueryVisitor implements IQueryVisitor<QuerySerializer>,
         return this.serializer;
     }
 
-    visitFields(expr: Fields): RecordArraySerializer {
+    visitFields(expr: IFields): RecordArraySerializer {
         return expr.accept(this.fields);
     }
 
-    visitField(expr: Field): RecordArraySerializer {
+    visitField(expr: IField): RecordArraySerializer {
         return expr.accept(this.fields);
     }
 
-    visitFilter(expr: Filter): RecordSerializer {
+    visitFilter(expr: IFilter): RecordSerializer {
         return expr.accept(this.filters);
     }
 
-    visitFilters(expr: Filters): RecordSerializer {
+    visitFilters(expr: IFilters): RecordSerializer {
         return expr.accept(this.filters);
     }
 
-    visitPagination(expr: Pagination): RecordSerializer {
+    visitPagination(expr: IPagination): RecordSerializer {
         return expr.accept(this.pagination);
     }
 
-    visitRelation(expr: Relation): ArraySerializer {
+    visitRelation(expr: IRelation): ArraySerializer {
         return expr.accept(this.relations);
     }
 
-    visitRelations(expr: Relations): ArraySerializer {
+    visitRelations(expr: IRelations): ArraySerializer {
         return expr.accept(this.relations);
     }
 
-    visitSort(expr: Sort): ArraySerializer {
+    visitSort(expr: ISort): ArraySerializer {
         return expr.accept(this.sort);
     }
 
-    visitSorts(expr: Sorts): ArraySerializer {
+    visitSorts(expr: ISorts): ArraySerializer {
         return expr.accept(this.sort);
     }
 }

packages/codec-url-simple/src/types.ts

@@ -5,11 +5,11 @@
  * view the LICENSE file that was distributed with this source code.
  */
 
-import type { ObjectLiteral, Query } from '@rapiq/core';
+import type { IQuery, ObjectLiteral } from '@rapiq/core';
 
 export interface IEncoder<
     OUTPUT = any,
     OPTIONS extends ObjectLiteral = ObjectLiteral,
 > {
-    encode(input: Query, options?: Partial<OPTIONS>) : OUTPUT
+    encode(input: IQuery, options?: Partial<OPTIONS>) : OUTPUT
 }

packages/core/package.json

@@ -58,7 +58,6 @@
     },
     "homepage": "https://github.com/Tada5hi/rapiq#readme",
     "dependencies": {
-        "@ucast/core": "^1.10.2",
         "pathtrace": "^1.1.0",
         "smob": "^1.5.0"
     },

packages/core/src/parameter/fields/collection/module.ts

@@ -5,44 +5,33 @@
  * view the LICENSE file that was distributed with this source code.
  */
 
+import type { IField } from '../record';
 import { Field } from '../record';
 import { FieldOperator } from '../../../schema';
-import type { IFieldsVisitor } from './types';
+import type { IFields, IFieldsVisitor } from './types';
 
 type FieldsExecuteOptions = {
     default: string[],
     allowed: string[],
 };
 
-export class Fields {
-    readonly value : Field[];
+export class Fields implements IFields {
+    readonly value : IField[];
 
-    constructor(value : Field[] = []) {
+    constructor(value : IField[] = []) {
         this.value = value;
     }
 
     accept<R>(visitor: IFieldsVisitor<R>): R {
         return visitor.visitFields(this);
     }
 
-    mergeWith(input: Fields | Field) {
-        if (input instanceof Field) {
-            this.value.push(input);
-        }
-
-        if (input instanceof Fields) {
-            for (let i = 0; i < input.value.length; i++) {
-                this.value.push(input.value[i]);
-            }
-        }
-    }
-
     /**
      * Extract field set, with includes and excludes.
      *
      * @param options
      */
-    execute(options: FieldsExecuteOptions) : Fields {
+    execute(options: FieldsExecuteOptions) : IFields {
         const includes : string[] = [];
         const excludes : string[] = [];
         const explicates : string[] = [];

packages/core/src/parameter/fields/collection/types.ts

@@ -5,8 +5,14 @@
  * view the LICENSE file that was distributed with this source code.
  */
 
-import type { Fields } from './module';
+import type { IField } from '../record';
 
 export interface IFieldsVisitor<R> {
-    visitFields(expr: Fields): R;
+    visitFields(expr: IFields): R;
+}
+
+export interface IFields {
+    readonly value: IField[]
+
+    accept<R>(visitor: IFieldsVisitor<R>): R;
 }

packages/core/src/parameter/fields/record/module.ts

@@ -5,10 +5,10 @@
  * view the LICENSE file that was distributed with this source code.
  */
 
-import type { IFieldVisitor } from './types';
+import type { IField, IFieldVisitor } from './types';
 
-export class Field {
-    name: string;
+export class Field implements IField {
+    readonly name: string;
 
     readonly operator: string | undefined;
 

packages/core/src/parameter/fields/record/types.ts

@@ -10,3 +10,11 @@ import type { Field } from './module';
 export interface IFieldVisitor<R> {
     visitField(expr: Field): R;
 }
+
+export interface IField {
+    readonly name: string;
+
+    readonly operator: string | undefined;
+
+    accept<R>(visitor: IFieldVisitor<R>): R;
+}