First commit

Author: ProGM

.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": ["@babel/preset-typescript"]
+}

.editorconfig

@@ -0,0 +1,12 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

.github/workflows/test.yml

@@ -0,0 +1,17 @@
+name: Tests
+on: [push, pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node: [ '12', '14', '16' ]
+    name: Node ${{ matrix.node }} sample
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup node
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+      - run: yarn install
+      - run: yarn test

.gitignore

@@ -0,0 +1 @@
+/node_modules

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Mònade srl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,45 @@
+![Tests](https://github.com/monade/json-api-parser/actions/workflows/test.yml/badge.svg)
+
+# @monade/json-api-parser
+
+A parser for [JSON:API](https://jsonapi.org/) format that maps data to models using decorators, inspired by retrofit.
+
+## Installation
+
+```bash
+  npm install https://github.com/monade/json-api-parser.git
+```
+
+## Example usage
+
+```typescript
+import { Attr, JSONAPI, Model, Rel } from "../src";
+
+export const DateParser = (data: any) => new Date(data);
+
+@JSONAPI("posts")
+export class Post extends Model {
+  @Attr() name!: string;
+  @Attr("description") content!: string;
+  @Attr("created_at", { parser: DateParser }) createdAt!: Date;
+  @Attr("active", { default: true }) enabled!: boolean;
+  @Attr() missing!: boolean;
+
+  @Rel("user") author!: User;
+  @Rel() reviewer!: User | null;
+}
+
+@JSONAPI("users")
+class User extends Model {
+  @Attr() firstName!: string;
+  @Attr() lastName!: string;
+  @Attr("created_at", { parser: DateParser }) createdAt!: Date;
+
+  @Rel() favouritePost!: Post;
+}
+```
+
+## TODO
+* Documentation
+* Edge case tests
+* Release on NPM

dist/index.cjs.js

@@ -0,0 +1,232 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class Model {
+  toJSON() {
+    return { ...this
+    };
+  }
+
+  toFormData() {
+    const data = this.toJSON();
+    const formData = new FormData();
+
+    for (const key in data) {
+      if (data[key] === null || data[key] === undefined) {
+        continue;
+      }
+
+      if (Array.isArray(data[key])) {
+        for (const value of data[key]) {
+          formData.append(key + "[]", value);
+        }
+      } else if (data[key] instanceof File) {
+        formData.append(key, data[key], data[key].filename);
+      } else {
+        formData.append(key, data[key]);
+      }
+    }
+
+    return formData;
+  }
+
+}
+
+function debug(...args) {
+  debug.adapter(...args);
+}
+
+debug.adapter = (...args) => console.warn(...args);
+
+class Parser {
+  static $registeredModels = [];
+  static $registeredAttributes = [];
+  static $registeredRelationships = [];
+  resolved = {};
+
+  constructor(data, included = []) {
+    this.data = data;
+    this.included = included;
+  }
+
+  run() {
+    if (!this.data) {
+      return null;
+    }
+
+    const {
+      data,
+      included
+    } = this;
+    const fullIncluded = Array.isArray(data) ? [...data, ...included] : [data, ...included];
+    return this.parse(data, fullIncluded);
+  }
+
+  parse(data, included = []) {
+    if (!data) {
+      return null;
+    }
+
+    if (Array.isArray(data)) {
+      return this.parseList(data, included);
+    } else if ("data" in data && !("id" in data)) {
+      return this.parse(data.data, data.included || included);
+    } else {
+      return this.parseElement(data, included);
+    }
+  }
+
+  parseList(list, included) {
+    return list.map(e => {
+      return this.parseElement(e, included);
+    });
+  }
+
+  parseElement(element, included) {
+    const uniqueKey = `${element.id}$${element.type}`;
+
+    if (this.resolved[uniqueKey]) {
+      return this.resolved[uniqueKey];
+    }
+
+    const loadedElement = Parser.load(element, included);
+    const model = Parser.$registeredModels.find(e => e.type === loadedElement.type);
+    const attrData = Parser.$registeredAttributes.find(e => e.klass === model?.klass);
+    const relsData = Parser.$registeredRelationships.find(e => e.klass === model?.klass);
+    const instance = new (model?.klass || Model)();
+    this.resolved[uniqueKey] = instance;
+    instance.id = loadedElement.id;
+
+    for (const key in loadedElement.attributes) {
+      const parser = attrData?.attributes?.[key];
+
+      if (parser) {
+        instance[parser.key] = parser.parser(loadedElement.attributes[key]);
+      } else {
+        instance[key] = loadedElement.attributes[key];
+        debug(`Undeclared key "${key}" in "${loadedElement.type}"`);
+      }
+    }
+
+    if (attrData) {
+      for (const key in attrData.attributes) {
+        const parser = attrData.attributes[key];
+
+        if (!(parser.key in instance)) {
+          if ("default" in parser) {
+            instance[parser.key] = parser.default;
+          } else {
+            debug(`Missing attribute "${key}" in "${loadedElement.type}"`);
+          }
+        }
+      }
+    }
+
+    for (const key in loadedElement.relationships) {
+      const relation = loadedElement.relationships[key];
+      const parser = relsData?.attributes?.[key];
+
+      if (parser) {
+        instance[parser.key] = parser.parser(this.parse(relation, included));
+      } else {
+        instance[key] = this.parse(relation, included);
+        debug(`Undeclared relationship "${key}" in "${loadedElement.type}"`);
+      }
+    }
+
+    if (relsData) {
+      for (const key in relsData.attributes) {
+        const parser = relsData.attributes[key];
+
+        if (!(parser.key in instance)) {
+          if ("default" in parser) {
+            instance[parser.key] = parser.default;
+          } else {
+            debug(`Missing relationships "${key}" in "${loadedElement.type}"`);
+          }
+        }
+      }
+    }
+
+    return instance;
+  }
+
+  static load(element, included) {
+    const found = included.find(e => e.id == element.id && e.type === element.type);
+
+    if (!found) {
+      debug(`Relationship with type ${element.type} with id ${element.id} not present in included`);
+    }
+
+    return found || { ...element,
+      $_partial: true
+    };
+  }
+
+}
+
+function Attr(sourceKey, options = {
+  parser: v => v
+}) {
+  return function _Attr(klass, key) {
+    let model = Parser.$registeredAttributes.find(e => e.klass === klass.constructor);
+
+    if (!model) {
+      model = {
+        attributes: {},
+        klass: klass.constructor
+      };
+      Parser.$registeredAttributes.push(model);
+    }
+
+    const data = {
+      parser: options.parser ?? (v => v),
+      key
+    };
+
+    if ("default" in options) {
+      data.default = options.default;
+    }
+
+    model.attributes[sourceKey ?? key] = data;
+  };
+}
+
+function Rel(sourceKey, options = {
+  parser: v => v
+}) {
+  return function _Rel(klass, key) {
+    let model = Parser.$registeredRelationships.find(e => e.klass === klass.constructor);
+
+    if (!model) {
+      model = {
+        attributes: {},
+        klass: klass.constructor
+      };
+      Parser.$registeredRelationships.push(model);
+    }
+
+    model.attributes[sourceKey ?? key] = {
+      parser: options.parser ?? (v => v),
+      key,
+      default: options.default
+    };
+  };
+}
+
+function JSONAPI(type) {
+  return function _JSONAPI(constructor) {
+    Parser.$registeredModels.push({
+      klass: constructor,
+      type
+    });
+  };
+}
+
+exports.Attr = Attr;
+exports.JSONAPI = JSONAPI;
+exports.Model = Model;
+exports.Parser = Parser;
+exports.Rel = Rel;
+exports.debug = debug;