Refactor code

Author: Boris Abramov

package.json

@@ -20,6 +20,11 @@
     "./types": "./build/src/types.js",
     "./commands": "./build/commands/main.js"
   },
+  "imports": {
+    "#common/*": "./src/common/*.js",
+    "#utils/*": "./src/utils/*.js",
+    "#processors/*": "./src/processors/*.js"
+  },
   "scripts": {
     "clean": "del-cli build",
     "copy:templates": "copyfiles \"stubs/**/*.stub\" build",

src/common/types.ts

@@ -0,0 +1,43 @@
+/*
+ * adonis-api-resources
+ *
+ * (c) Boris Abramov <boris@rykantas.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export type Data = object | object[]
+
+export interface Processor {
+  pick: Function
+  omit: Function
+  remap: Function
+}
+
+export interface PaginationMeta {
+  total: number
+  perPage: number
+  currentPage: number
+  lastPage: number
+  firstPage: number
+  firstPageUrl: string
+  lastPageUrl: string
+  nextPageUrl: string | null
+  previousPageUrl: string | null
+}
+
+export interface PaginatedORMData {
+  rows: object[]
+  meta: PaginationMeta
+}
+
+export interface PaginatedODMData {
+  data: object[]
+  meta: PaginationMeta
+}
+
+export interface PaginatedData {
+  data: object[]
+  meta: PaginationMeta
+}

src/processors/collection.ts

@@ -0,0 +1,35 @@
+/*
+ * adonis-api-resources
+ *
+ * (c) Boris Abramov <boris@rykantas.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Processor } from '#common/types'
+import { pick as pickEntity, omit as omitEntity } from '#utils/parsers'
+
+export default class CollectionProcessor implements Processor {
+  pick(data: object[], ...keys: string[]) {
+    let result = []
+    for (let entity of data) {
+      result.push(pickEntity(entity, keys))
+    }
+    return result
+  }
+
+  omit(data: object[], ...keys: string[]) {
+    let result = []
+    for (let entity of data) {
+      result.push(omitEntity(entity, keys))
+    }
+    return result
+  }
+
+  remap(data: object[], defineMap: Function): object[] {
+    return data.map((item) => {
+      return defineMap(item)
+    })
+  }
+}

src/processors/entity.ts

@@ -0,0 +1,25 @@
+/*
+ * adonis-api-resources
+ *
+ * (c) Boris Abramov <boris@rykantas.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Processor } from '#common/types'
+import { pick as pickEntity, omit as omitEntity } from '#utils/parsers'
+
+export default class EntityProcessor implements Processor {
+  pick(data: object, ...keys: string[]): object {
+    return pickEntity(data, keys)
+  }
+
+  omit(data: object, ...keys: string[]): object {
+    return omitEntity(data, keys)
+  }
+
+  remap(data: object, defineMap: Function): object {
+    return defineMap(data)
+  }
+}

src/processors/paginated.ts

@@ -0,0 +1,50 @@
+/*
+ * adonis-api-resources
+ *
+ * (c) Boris Abramov <boris@rykantas.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { PaginatedData, PaginatedODMData, PaginatedORMData, Processor } from '#common/types'
+import CollectionProcessor from '#processors/collection'
+
+export default class PaginatedProcessor implements Processor {
+  constructor(private collectionProcessor: CollectionProcessor) {}
+
+  private extractCollection(data: PaginatedORMData | PaginatedODMData): object[] {
+    return 'rows' in data ? data.rows : data.data
+  }
+
+  private extractMeta(data: PaginatedORMData | PaginatedODMData) {
+    if ('getMeta' in data) {
+      if (typeof data.getMeta === 'function') {
+        return data.getMeta()
+      } else {
+        return data.meta
+      }
+    } else return {}
+  }
+
+  pick(data: PaginatedORMData | PaginatedODMData, ...keys: string[]): PaginatedData {
+    return {
+      meta: this.extractMeta(data),
+      data: this.collectionProcessor.pick(this.extractCollection(data), ...keys),
+    }
+  }
+
+  omit(data: PaginatedORMData | PaginatedODMData, ...keys: string[]): PaginatedData {
+    return {
+      meta: this.extractMeta(data),
+      data: this.collectionProcessor.omit(this.extractCollection(data), ...keys),
+    }
+  }
+
+  remap(data: PaginatedORMData | PaginatedODMData, defineMap: Function): PaginatedData {
+    return {
+      meta: this.extractMeta(data),
+      data: this.collectionProcessor.remap(this.extractCollection(data), defineMap),
+    }
+  }
+}

src/resource.ts

@@ -1,156 +1,91 @@
 /*
  * adonis-api-resources
  *
- * (c) Boris Abramov <boris@ideainc.eu>
+ * (c) Boris Abramov <boris@rykantas.com>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
 
+import { type Data, Processor } from '#common/types'
+import EntityProcessor from '#processors/entity'
+import CollectionProcessor from '#processors/collection'
+import PaginatedProcessor from '#processors/paginated'
+import { paginate } from '#utils/paginate'
+
 export abstract class Resource {
-  constructor(private data: any) {}
+  constructor(private data: Data) {}
+
+  private _processor?: Processor
 
-  abstract defineMap(data: any): object
+  abstract defineMap(data: object): object
 
-  private isPaginated(): boolean {
-    const ormPaginated = 'rows' in this.data && 'currentPage' in this.data
-    const odmPaginated = 'data' in this.data && 'meta' in this.data
+  private isPaginated(data: Data): boolean {
+    const ormPaginated = 'rows' in data && 'currentPage' in data
+    const odmPaginated = 'data' in data && 'meta' in data
     const indeedPaginated = ormPaginated || odmPaginated
-    if (odmPaginated) this.data.getMeta = () => this.data.meta
+    if (odmPaginated) (data as any).getMeta = () => (data as any).meta
     return indeedPaginated
   }
 
-  private isCollection(): boolean {
-    return Array.isArray(this.data)
-  }
-
-  private parsePaginated(meta: object, data: object): object {
-    return {
-      meta: meta,
-      data: data,
-    }
-  }
-
-  private redefineEntity(data: any): object {
-    return this.defineMap(data)
+  private isCollection(data: Data): boolean {
+    return Array.isArray(data)
   }
 
-  private redefineCollection(data: any[]): object {
-    return data.map((item) => {
-      return this.redefineEntity(item)
-    })
-  }
-
-  private pickEntity(entity: object, keys: string[]) {
-    return Object.assign({}, ...keys.map((key) => ({ [key]: (entity as any)[key] })))
-  }
-
-  private pickCollection(data: object[], keys: string[]) {
-    let result = []
-    for (let entity of data) {
-      result.push(this.pickEntity(entity, keys))
+  private processor(): Processor {
+    if (!this._processor) {
+      if (this.isPaginated(this.data)) {
+        this._processor = new PaginatedProcessor(new CollectionProcessor())
+      } else if (this.isCollection(this.data)) {
+        this._processor = new CollectionProcessor()
+      } else {
+        this._processor = new EntityProcessor()
+      }
     }
-    return result
+    return this._processor
   }
 
-  private omitEntity(entity: object, keys: string[]) {
-    const exclude = new Set(keys)
-    const o =
-      'serialize' in entity && typeof entity.serialize === 'function' ? entity.serialize() : entity
-    return Object.fromEntries(Object.entries(o).filter((e) => !exclude.has(e[0])))
+  pick(...keys: string[]) {
+    const processor = this.processor()
+    this.data = processor.pick(this.data, ...keys)
+    return this
   }
 
-  private omitCollection(data: object[], keys: string[]) {
-    let result = []
-    for (let entity of data) {
-      result.push(this.omitEntity(entity, keys))
-    }
-    return result
+  omit(...keys: string[]): this {
+    const processor = this.processor()
+    this.data = processor.omit(this.data, ...keys)
+    return this
   }
 
-  pick(...keys: string[]): this {
-    if (this.isPaginated()) {
-      this.data = this.parsePaginated(
-        (this.data as any).getMeta(),
-        this.pickCollection((this.data as any).rows || (this.data as any).data, keys)
-      )
-    } else if (this.isCollection()) {
-      this.data = this.pickCollection(this.data, keys)
-    } else {
-      this.data = this.pickEntity(this.data, keys)
-    }
+  remap(): this {
+    const processor = this.processor()
+    this.data = processor.remap(this.data, this.defineMap)
     return this
   }
 
-  omit(...keys: string[]): this {
-    if (this.isPaginated()) {
-      this.data = this.parsePaginated(
-        (this.data as any).getMeta(),
-        this.omitCollection((this.data as any).rows || (this.data as any).data, keys)
-      )
-    } else if (this.isCollection()) {
-      this.data = this.omitCollection(this.data, keys)
-    } else {
-      this.data = this.omitEntity(this.data, keys)
+  paginate(page: number = 1, limit: number = 10): this {
+    if (!this.isCollection(this.data)) {
+      throw new Error('Pagination requires an array of objects')
     }
+    this.data = paginate(this.data as Array<object>, page, limit)
     return this
   }
 
+  // Obsolete methods for backward compatibility
   redefine(): this {
-    if (this.isPaginated()) {
-      this.data = this.parsePaginated(
-        (this.data as any).getMeta(),
-        this.redefineCollection((this.data as any).rows || (this.data as any).data)
-      )
-    } else if (this.isCollection()) {
-      this.data = this.redefineCollection(this.data)
-    } else {
-      this.data = this.redefineEntity(this.data)
-    }
-    return this
+    return this.remap()
   }
-
-  refine(): object {
-    return this.redefine().get()
+  get(): this {
+    return this
   }
-
-  refinePaginate(page: number = 1, limit: number = 10): object {
-    return this.redefine().paginate(page, limit)
+  refine(): this {
+    return this.remap()
   }
-
-  paginate(page: number = 1, limit: number = 10) {
-    const lastPage = Math.max(Math.ceil(this.data.data.length / limit), 1)
-    interface PaginationMeta {
-      total: number
-      perPage: number
-      currentPage: number
-      lastPage: number
-      firstPage: number
-      firstPageUrl: string
-      lastPageUrl: string
-      nextPageUrl: string | null
-      previousPageUrl: string | null
-    }
-    const meta: PaginationMeta = {
-      total: this.data.length,
-      perPage: Math.floor(limit),
-      currentPage: Math.floor(page),
-      lastPage: lastPage,
-      firstPage: 1,
-      firstPageUrl: '/?page=1',
-      lastPageUrl: '/?page=' + lastPage,
-      nextPageUrl: page < lastPage ? `/?page=${page + 1}` : null,
-      previousPageUrl: page > 1 ? `/?page=${page - 1}` : null,
-    }
-    const collection = (this.data.rows || this.data.data).slice((page - 1) * limit, page * limit)
-    this.data = {
-      meta: meta,
-      data: collection,
-    }
-    return this.data
+  refinePaginate(page: number = 1, limit: number = 10): this {
+    return this.remap().paginate(page, limit)
   }
+}
 
-  get() {
-    return this.data
-  }
+;(Resource.prototype as any).toJSON = function () {
+  return (this as any).data
 }