Merge branch 'feature/2-implement-schema-field-mapping'

Close #2

Author: stantanasi

example/src/models/article.model.ts

@@ -25,9 +25,13 @@ export const ArticleSchema = new Schema<IArticle>({
   },
 
   relationships: {
-    author: {},
+    author: {
+      type: 'people',
+    },
 
-    comments: {},
+    comments: {
+      type: 'comments',
+    },
   },
 });
 

example/src/models/comment.model.ts

@@ -25,9 +25,13 @@ export const CommentSchema = new Schema<IComment>({
   },
 
   relationships: {
-    article: {},
+    article: {
+      type: 'articles',
+    },
 
-    author: {},
+    author: {
+      type: 'people',
+    },
   },
 });
 

example/src/models/people.model.ts

@@ -31,9 +31,13 @@ export const PeopleSchema = new Schema<IPeople>({
   },
 
   relationships: {
-    articles: {},
+    articles: {
+      type: 'articles',
+    },
 
-    comments: {},
+    comments: {
+      type: 'comments',
+    },
   },
 });
 

src/lib/model.ts

@@ -192,8 +192,10 @@ BaseModel.fromJsonApi = function (body) {
     }
 
     // Attributes
-    for (let [attribute, value] of Object.entries(body.data.attributes ?? {})) {
-      const property = schema.attributes[attribute];
+    for (let [name, value] of Object.entries(body.data.attributes ?? {})) {
+      const [attribute, property] = Object.entries(schema.attributes)
+        .find(([_, property]) => property?.name === name)
+        ?? [name, schema.attributes[name]];
 
       if (property?.type === Date && value) {
         value = new Date(value);
@@ -203,7 +205,11 @@ BaseModel.fromJsonApi = function (body) {
     }
 
     // Relationships
-    for (const [relationship, value] of Object.entries(body.data.relationships ?? {})) {
+    for (const [name, value] of Object.entries(body.data.relationships ?? {})) {
+      const [relationship, property] = Object.entries(schema.relationships)
+        .find(([_, property]) => property?.name === name)
+        ?? [name, schema.relationships[name]];
+
       if (Array.isArray(value.data)) {
         const related = value.data.map((identifier) => {
           const model = models[identifier.type];
@@ -473,24 +479,28 @@ BaseModel.prototype.toJsonApi = function () {
       }
     }
 
-    data.attributes![attribute] = value;
+    const name = property?.name ?? attribute;
+
+    data.attributes![name] = value;
   }
 
   for (const [relationship, property] of Object.entries(this.schema.relationships)) {
     if (!this.isNew && !this.isModified(relationship)) continue;
 
     const value = this.get(relationship) as ModelInstance<Record<string, any>> | ModelInstance<Record<string, any>>[] | null;
 
+    const name = property?.name ?? relationship;
+
     if (Array.isArray(value)) {
-      data.relationships![relationship] = {
+      data.relationships![name] = {
         data: value.map((val) => val.identifier()),
       };
     } else if (value) {
-      data.relationships![relationship] = {
+      data.relationships![name] = {
         data: value.identifier(),
       };
     } else {
-      data.relationships![relationship] = {
+      data.relationships![name] = {
         data: null,
       };
     }

src/lib/query.ts

@@ -1,5 +1,5 @@
-import { JsonApiBody, JsonApiResource } from "../types/jsonapi.type";
-import { fromJsonApi, Model, ModelConstructor, ModelInstance } from "./model";
+import { JsonApiBody, JsonApiQueryParams, JsonApiResource } from "../types/jsonapi.type";
+import { fromJsonApi, Model, ModelConstructor, ModelInstance, models } from "./model";
 import Schema from "./schema";
 
 type RawResultType<T> = {
@@ -54,6 +54,8 @@ class Query<ResultType, DocType> {
     this.init(model);
   }
 
+  buildParams!: () => JsonApiQueryParams;
+
   catch!: Promise<ResultType>['catch'];
 
   exec!: () => Promise<ResultType>;
@@ -129,62 +131,133 @@ Query.prototype.init = function (model) {
   this.options = {};
 };
 
-Query.prototype.catch = function (reject) {
-  return this.exec().then(null, reject);
-};
+Query.prototype.buildParams = function () {
+  const options = this.getOptions();
 
-Query.prototype.exec = async function exec() {
-  const client = this.model.client;
+  const getJsonApiName = (
+    key: string,
+    schema?: Schema<any>,
+  ): string => {
+    if (schema?.attributes[key]) {
+      return schema.attributes[key].name ?? key;
+    } else if (schema?.relationships[key]) {
+      return schema.relationships[key].name ?? key;
+    }
+    return key;
+  };
 
-  const flattenIncludeQuery = (obj: IncludeQuery<any>, prefix = ''): string[] => {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-      const path = prefix ? `${prefix}.${key}` : key;
-
-      if (typeof value === 'boolean') {
-        return value
-          ? acc.concat(path)
-          : acc;
-      } else {
-        const childPaths = flattenIncludeQuery(value ?? {}, path);
-        return childPaths.length > 0
-          ? acc.concat(childPaths)
-          : acc.concat(path);
-      }
-    }, [] as string[]);
+  const buildFilterParams = (
+    filter: FilterQuery<any>,
+    schema?: Schema<any>,
+  ): JsonApiQueryParams['filter'] => {
+    return Object.fromEntries(
+      Object.entries(filter).map(([key, value]) => [getJsonApiName(key, schema), value])
+    );
   };
 
-  const options = this.getOptions();
-  const params = {
-    filter: options.filter,
-    include: options.include
-      ? flattenIncludeQuery(options.include).join(',')
-      : undefined,
-    fields: options.fields
-      ? Object.fromEntries(
-        Object.entries(options.fields).map(([type, fields]) => [type, fields.join(',')])
-      )
-      : undefined,
-    sort: options.sort
-      ? Object.entries(options.sort)
-        .map(([field, order]) => {
-          if (order === -1 || order === 'desc' || order === 'descending') {
-            return `-${field}`;
-          }
-          return field;
-        })
-        .join(',')
-      : undefined,
+  const buildIncludeParams = (
+    include: IncludeQuery<any>,
+    schema?: Schema<any>,
+  ): JsonApiQueryParams['include'] => {
+    const flattenInclude = (
+      obj: IncludeQuery<any>,
+      schema?: Schema<any>,
+      prefix = '',
+    ): string[] => {
+      return Object.entries(obj).flatMap(([key, value]) => {
+        let name = schema?.relationships[key]?.name ?? key;
+        const path = prefix ? `${prefix}.${name}` : name;
+
+        if (typeof value === 'boolean') {
+          return value ? [path] : [];
+        }
+
+        const subType = schema?.relationships[key]?.type;
+        const subSchema = Array.isArray(subType)
+          ? models[subType[0]].schema
+          : subType
+            ? models[subType].schema
+            : undefined;
+
+        const subPaths = flattenInclude(value ?? {}, subSchema, path);
+        return subPaths.length ? subPaths : [path];
+      });
+    };
+
+    return flattenInclude(include, schema).join(',');
+  };
+
+  const buildFieldsParams = (
+    fields: FieldsQuery,
+  ): JsonApiQueryParams['fields'] => {
+    return Object.fromEntries(
+      Object.entries(fields).map(([type, list]) => {
+        const schema = models[type]?.schema;
+
+        const names = list
+          .map((field) => getJsonApiName(field, schema))
+          .join(',');
+
+        return [type, names];
+      })
+    );
+  };
+
+  const buildSortParams = (
+    sort: SortQuery<any>,
+    schema?: Schema<any>,
+  ): JsonApiQueryParams['sort'] => {
+    return Object.entries(sort)
+      .map(([key, order]) => {
+        let name = getJsonApiName(key, schema)
+
+        if (order === -1 || order === 'desc' || order === 'descending') {
+          return `-${name}`;
+        }
+        return name;
+      })
+      .join(',');
+  };
+
+  const getSchema = () => {
+    if (options.op === 'findRelationship' && options.related) {
+      const property = this.model.schema.relationships[options.related];
+      return Array.isArray(property?.type)
+        ? models[property.type[0]].schema
+        : property?.type
+          ? models[property.type].schema
+          : undefined;
+    }
+    return this.model.schema;
+  };
+  const schema = getSchema();
+
+  return {
+    filter: options.filter ? buildFilterParams(options.filter, schema) : undefined,
+    include: options.include ? buildIncludeParams(options.include, schema) : undefined,
+    fields: options.fields ? buildFieldsParams(options.fields) : undefined,
+    sort: options.sort ? buildSortParams(options.sort, schema) : undefined,
     page: {
       limit: options.limit,
       offset: options.offset,
     },
   };
+};
+
+Query.prototype.catch = function (reject) {
+  return this.exec().then(null, reject);
+};
+
+Query.prototype.exec = async function exec() {
+  const client = this.model.client;
+
+  const options = this.getOptions();
 
   if (options.op === 'find') {
     const response = await client.client.get<JsonApiBody<JsonApiResource[]>>(
       `/${this.model.type}`,
       {
-        params: params,
+        params: this.buildParams(),
       }
     );
 
@@ -200,7 +273,7 @@ Query.prototype.exec = async function exec() {
     const response = await client.client.get<JsonApiBody<JsonApiResource | null>>(
       `/${this.model.type}/${options.id}`,
       {
-        params: params,
+        params: this.buildParams(),
       }
     );
 
@@ -216,7 +289,7 @@ Query.prototype.exec = async function exec() {
     const response = await client.client.get<JsonApiBody<JsonApiResource | null>>(
       `/${this.model.type}/${options.id}/${options.related}`,
       {
-        params: params,
+        params: this.buildParams(),
       }
     );
 

src/lib/schema.ts

@@ -8,6 +8,9 @@ type AttributesDefinition<DocType> = {
 }
 
 type AttributeDefinition<T> = {
+  /** The JSON:API attribute name. */
+  name?: string;
+
   type?: typeof Date;
 
   /** The default value for this property. */
@@ -31,6 +34,15 @@ type RelationshipsDefinition<DocType> = {
 }
 
 type RelationshipDefinition<T> = {
+  /** 
+   * The JSON:API relationship type.
+   * Only used to find the JSON:API relationship `name` when calling `.include()`.
+   */
+  type?: string | string[];
+
+  /** The JSON:API relationship name. */
+  name?: string;
+
   /** The default value for this property. */
   default?: T | (() => T);