@bjornharrtell/json-api 2.0.4 → 4.0.2

package/README.md

@@ -1,6 +1,6 @@
 # json-api
 
-json-api can fetch typed data models via an JSON:API endpoint into record instances.
+json-api can fetch typed data models via a JSON:API endpoint into record instances.
 
 An instance is created with an endpoint and model definitions and the instance API provides methods `findAll`, `findRecord` to fetch record(s). Included relationships will be automatically resolved. If relationships for a record are not included they can be fetched later using `findRelated`.
 
@@ -9,44 +9,45 @@ An instance is created with an endpoint and model definitions and the instance A
 A service returning the canonical example JSON:API document at https://jsonapi.org/ can be consumed this way:
 
 ```ts
-import { useJsonApi, Model, type ModelDefinition, RelationshipType } from '@bjornharrtell/json-api'
+import { useJsonApi, type BaseRecord, type ModelDefinition, RelationshipType } from '@bjornharrtell/json-api'
 
-export class Person extends Model {
+export interface Person extends BaseRecord {
   firstName?: string
   lastName?: string
   twitter?: string
 }
 
-export class Comment extends Model {
+export interface Comment extends BaseRecord {
   body?: string
+  author?: Person | null
 }
 
-export class Article extends Model {
+export interface Article extends BaseRecord {
   title?: string
-  author: Person | null = null
-  comments: Comment[] = []
+  author?: Person | null
+  comments?: Comment[]
 }
 
 const modelDefinitions: ModelDefinition[] = [
   {
-    type: 'person',
-    ctor: Person,
+    type: 'people',
   },
   {
-    type: 'comment',
-    ctor: Comment,
+    type: 'comments',
+    relationships: {
+      author: { type: 'people', relationshipType: RelationshipType.BelongsTo },
+    },
   },
   {
-    type: 'article',
-    ctor: Article,
-    rels: {
-      author: { ctor: Person, type: RelationshipType.BelongsTo },
-      comments: { ctor: Comment, type: RelationshipType.HasMany },
+    type: 'articles',
+    relationships: {
+      author: { type: 'people', relationshipType: RelationshipType.BelongsTo },
+      comments: { type: 'comments', relationshipType: RelationshipType.HasMany },
     },
   },
 ]
 
-export const aticlesApi = useJsonApi({
+export const articlesApi = useJsonApi({
   endpoint: 'http://localhost/api',
   modelDefinitions,
 })
@@ -55,14 +56,17 @@ export const aticlesApi = useJsonApi({
 The above can then be used as follows:
 
 ```ts
-import aticlesApi from './api/articles'
-const { records: articles } = await aticlesApi.findAll(Article, { include: ['comments', 'author'] })
+import { articlesApi, type Article } from './api/articles'
+
+const { records: articles } = await articlesApi.findAll<Article>('articles', { 
+  include: ['comments', 'author'] 
+})
 expect(articles.length).toBe(1)
 const article = articles[0]
 expect(article.id).toBe('1')
 expect(article.title).toBe('JSON:API paints my bikeshed!')
-expect(article.comments.length).toBe(2)
-expect(article.comments[0].body).toBe('First!')
-expect(article.comments[1].body).toBe('I like XML better')
+expect(article.comments?.length).toBe(2)
+expect(article.comments?.[0]?.body).toBe('First!')
+expect(article.comments?.[1]?.body).toBe('I like XML better')
 expect(article.author?.firstName).toBe('Dan')
-```
+```

package/dist/lib.d.ts

@@ -1,3 +1,7 @@
+export declare interface BaseEntity {
+    id: string;
+}
+
 /**
  * Convert str from kebab-case to camelCase
  */
@@ -92,33 +96,34 @@ export declare interface JsonApiResourceIdentifier {
 }
 
 export declare interface JsonApiStore {
-    /**
-     * Models registered with this store
-     */
-    modelRegistry: Map<typeof Model, string>;
-    /**
-     * Relationships registered with this store
-     */
-    relRegistry: Map<typeof Model, Record<string, Relationship>>;
-    /* Excluded from this release type: createRecord */
     /**
      * Find all records of a given type
      * @returns the JSON API document that was fetched and the records that were found
      */
-    findAll<T extends typeof Model>(ctor: T, options?: FetchOptions, params?: FetchParams): Promise<{
+    findAll<T extends BaseEntity>(type: string, options?: FetchOptions, params?: FetchParams): Promise<{
         doc: JsonApiDocument;
-        records: InstanceType<T>[];
+        records: T[];
     }>;
     /**
      * Find a single record by id
      * @returns the record that was found
      */
-    findRecord<T extends typeof Model>(ctor: T, id: string, options?: FetchOptions, params?: FetchParams): Promise<InstanceType<T>>;
+    findRecord<T extends BaseEntity>(type: string, id: string, options?: FetchOptions, params?: FetchParams): Promise<T>;
     /**
      * Find related records for a given record and relationship name
      * @returns the JSON API document that was fetched
      */
-    findRelated(record: Model, name: string, options?: FetchOptions, params?: FetchParams): Promise<JsonApiDocument>;
+    findRelated<T extends BaseEntity>(record: T, relationshipName: string, options?: FetchOptions, params?: FetchParams): Promise<JsonApiDocument>;
+    /**
+     * Create a new record instance
+     */
+    createRecord<T extends BaseEntity>(type: string, properties: Partial<T> & {
+        id?: string;
+    }): T;
+    /**
+     * Save a record
+     */
+    saveRecord<T extends BaseEntity>(record: T): Promise<void>;
 }
 
 export declare interface JsonApiStoreConfig {
@@ -139,27 +144,17 @@ export declare interface JsonApiStoreConfig {
 export declare type JsonApiStoreUseFunction = () => JsonApiStore;
 
 /**
- * Base class for models
+ * Model definition
  */
-export declare class Model {
-    id: string;
-    constructor(id: string);
-    [key: string]: unknown;
-}
-
 export declare interface ModelDefinition {
     /**
      * The JSON:API type for the model
      */
     type: string;
     /**
-     * The model constructor
+     * Optional relationships for the model
      */
-    ctor: typeof Model;
-    /**
-     * Relationships for the model
-     */
-    rels?: Record<string, Relationship>;
+    relationships?: Record<string, Relationship>;
 }
 
 export declare interface PageOption {
@@ -171,8 +166,10 @@ export declare interface PageOption {
  * Relationship definition
  */
 export declare interface Relationship {
-    ctor: typeof Model;
-    type: RelationshipType;
+    /** The JSON:API type name of the related model */
+    type: string;
+    /** The relationship type */
+    relationshipType: RelationshipType;
 }
 
 export declare enum RelationshipType {
@@ -180,16 +177,6 @@ export declare enum RelationshipType {
     BelongsTo = 1
 }
 
-export declare function useJsonApi(config: JsonApiStoreConfig, fetcher?: JsonApiFetcher): {
-    modelRegistry: Map<typeof Model, string>;
-    relsRegistry: Map<typeof Model, Record<string, Relationship>>;
-    findAll: <T extends typeof Model>(ctor: T, options?: FetchOptions, params?: FetchParams) => Promise<{
-        doc: JsonApiDocument;
-        records: InstanceType<T>[];
-    }>;
-    findRecord: <T extends typeof Model>(ctor: T, id: string, options?: FetchOptions, params?: FetchParams) => Promise<InstanceType<T>>;
-    findRelated: (record: Model, name: string, options?: FetchOptions, params?: FetchParams) => Promise<JsonApiDocument>;
-    saveRecord: (record: Model) => Promise<void>;
-};
+export declare function useJsonApi(config: JsonApiStoreConfig, fetcher?: JsonApiFetcher): JsonApiStore;
 
 export { }

package/dist/lib.js

@@ -1,163 +1,175 @@
-function O(...i) {
-  return new URL(i.join("/")).href;
+function b(...o) {
+  return new URL(o.join("/")).href;
 }
-async function R(i, t) {
-  const { headers: r, searchParams: c, method: a, signal: o, body: d } = t, l = `?${c}`, h = i.replace(/(?:\?.*?)?(?=#|$)/, l), y = await fetch(h, {
-    method: a,
+async function R(o, e) {
+  const { headers: r, searchParams: d, method: i, signal: s, body: a } = e, y = `?${d}`, m = o.replace(/(?:\?.*?)?(?=#|$)/, y), w = await fetch(m, {
+    method: i,
     headers: r,
-    signal: o,
-    body: d
+    signal: s,
+    body: a
   });
-  if (!y.ok) throw new Error(`HTTP error! status: ${y.status} ${y.statusText}`);
-  return await y.json();
+  if (!w.ok) throw new Error(`HTTP error! status: ${w.status} ${w.statusText}`);
+  return await w.json();
 }
-class x {
-  constructor(t) {
-    this.endpoint = t;
-  }
-  createOptions(t = {}, r = {}, c = !1, a) {
-    const o = new URLSearchParams(), d = new Headers(t.headers);
-    d.append("Accept", "application/vnd.api+json"), c && d.append("Content-Type", "application/vnd.api+json");
-    const l = { searchParams: o, headers: d, body: a };
-    if (t.fields)
-      for (const [h, y] of Object.entries(t.fields)) o.append(`fields[${h}]`, y.join(","));
-    t.page?.size && o.append("page[size]", t.page.size.toString()), t.page?.number && o.append("page[number]", t.page.number.toString()), t.include && o.append("include", t.include.join(",")), t.filter && o.append("filter", t.filter);
-    for (const [h, y] of Object.entries(r)) o.append(h, y);
-    return l;
-  }
-  async fetchDocument(t, r, c, a) {
-    const o = [this.endpoint, t];
-    r && o.push(r);
-    const d = O(...o);
-    return await R(d, this.createOptions(c, a));
-  }
-  async fetchAll(t, r, c) {
-    const a = O(this.endpoint, t);
-    return (await R(a, this.createOptions(r, c))).data;
-  }
-  async fetchOne(t, r, c, a) {
-    const o = O(this.endpoint, t, r);
-    return (await R(o, this.createOptions(c, a))).data;
-  }
-  async fetchHasMany(t, r, c, a, o) {
-    const d = O(this.endpoint, t, r, c);
-    return await R(d, this.createOptions(a, o));
-  }
-  async fetchBelongsTo(t, r, c, a, o) {
-    const d = O(this.endpoint, t, r, c);
-    return await R(d, this.createOptions(a, o));
-  }
-  async post(t) {
-    const r = O(this.endpoint, t.type), a = JSON.stringify({
-      data: t
-    }), o = this.createOptions({}, {}, !0, a);
-    return await R(r, o);
+class k {
+  constructor(e) {
+    this.endpoint = e;
+  }
+  createOptions(e = {}, r = {}, d = !1, i) {
+    const s = new URLSearchParams(), a = new Headers(e.headers);
+    a.append("Accept", "application/vnd.api+json"), d && a.append("Content-Type", "application/vnd.api+json");
+    const y = { searchParams: s, headers: a, body: i };
+    if (e.fields)
+      for (const [m, w] of Object.entries(e.fields)) s.append(`fields[${m}]`, w.join(","));
+    e.page?.size && s.append("page[size]", e.page.size.toString()), e.page?.number && s.append("page[number]", e.page.number.toString()), e.include && s.append("include", e.include.join(",")), e.filter && s.append("filter", e.filter);
+    for (const [m, w] of Object.entries(r)) s.append(m, w);
+    return y;
+  }
+  async fetchDocument(e, r, d, i) {
+    const s = [this.endpoint, e];
+    r && s.push(r);
+    const a = b(...s);
+    return await R(a, this.createOptions(d, i));
+  }
+  async fetchAll(e, r, d) {
+    const i = b(this.endpoint, e);
+    return (await R(i, this.createOptions(r, d))).data;
+  }
+  async fetchOne(e, r, d, i) {
+    const s = b(this.endpoint, e, r);
+    return (await R(s, this.createOptions(d, i))).data;
+  }
+  async fetchHasMany(e, r, d, i, s) {
+    const a = b(this.endpoint, e, r, d);
+    return await R(a, this.createOptions(i, s));
+  }
+  async fetchBelongsTo(e, r, d, i, s) {
+    const a = b(this.endpoint, e, r, d);
+    return await R(a, this.createOptions(i, s));
+  }
+  async post(e) {
+    const r = b(this.endpoint, e.type), i = JSON.stringify({
+      data: e
+    }), s = this.createOptions({}, {}, !0, i);
+    return await R(r, s);
   }
 }
-function F(i) {
-  return i.replace(/[-][a-z\u00E0-\u00F6\u00F8-\u00FE]/g, (t) => t.slice(1).toUpperCase());
+function H(o) {
+  return o.replace(/[-][a-z\u00E0-\u00F6\u00F8-\u00FE]/g, (e) => e.slice(1).toUpperCase());
 }
-class q {
-  constructor(t) {
-    this.id = t, this.id = t;
-  }
+const S = Symbol("jsonApiType");
+function z(o, e) {
+  return o[S] = e, o;
 }
-var J = /* @__PURE__ */ ((i) => (i[i.HasMany = 0] = "HasMany", i[i.BelongsTo = 1] = "BelongsTo", i))(J || {});
-function I(i, t) {
-  const r = t ?? new x(i.endpoint), c = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
-  for (const e of i.modelDefinitions) {
-    const n = e.ctor;
-    c.set(n, e.type), a.set(e.type, n), e.rels && o.set(n, e.rels);
-  }
-  function d(e) {
-    return i.kebabCase ? F(e) : e;
-  }
-  function l(e, n, f) {
-    const w = new e(n);
-    if (f)
-      for (const [p, u] of Object.entries(f)) u !== void 0 && (w[d(p)] = u);
-    return w;
-  }
-  function h(e) {
-    const n = c.get(e);
-    if (!n) throw new Error(`Model ${e.name} not defined`);
-    return n;
-  }
-  function y(e) {
-    const n = a.get(e);
-    if (!n) throw new Error(`Model with name ${e} not defined`);
-    return n;
-  }
-  function T(e, n, f) {
-    function w(s) {
-      return l(
-        y(s.type),
-        s.id,
-        s.attributes
-      );
+function A(o) {
+  return o[S];
+}
+function j(o, e, r) {
+  o[e] = r;
+}
+var B = /* @__PURE__ */ ((o) => (o[o.HasMany = 0] = "HasMany", o[o.BelongsTo = 1] = "BelongsTo", o))(B || {});
+function C(o, e) {
+  const r = e ?? new k(o.endpoint), d = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+  for (const t of o.modelDefinitions)
+    d.set(t.type, t), t.relationships && i.set(t.type, t.relationships);
+  function s(t) {
+    return o.kebabCase ? H(t) : t;
+  }
+  function a(t, c) {
+    if (!d.get(t)) throw new Error(`Model type ${t} not defined`);
+    const u = c.id ?? crypto.randomUUID(), f = { id: u, ...c };
+    if (z(f, t), o.kebabCase) {
+      const l = { id: u };
+      z(l, t);
+      for (const [h, n] of Object.entries(c))
+        h !== "id" && n !== void 0 && (l[s(h)] = n);
+      return l;
     }
-    const p = /* @__PURE__ */ new Map();
-    if (f) for (const s of f) p.set(s.id, w(s));
-    const u = n.map((s) => l(e, s.id, s.attributes)), g = /* @__PURE__ */ new Map();
-    for (const s of u) g.set(s.id, s);
-    function M(s) {
-      const D = g.get(s.id) ?? p.get(s.id);
-      if (!D) throw new Error("Unexpected not found record");
-      const j = y(s.type);
-      if (s.relationships)
-        for (const [b, $] of Object.entries(s.relationships)) {
-          const v = o.get(j);
-          if (!v) continue;
-          const H = d(b), E = v[H];
-          if (!E) throw new Error(`Relationship ${H} not defined`);
-          const P = h(E.ctor), k = E.type === 0 ? $.data : [$.data], U = k.filter((m) => m && p.has(m.id) && m.type === P).map((m) => p.get(m.id)), z = k.filter((m) => m && g.has(m.id) && m.type === P).map((m) => g.get(m.id));
-          z.push(...U), D[H] = E.type === 0 ? z : z[0];
+    return f;
+  }
+  function y(t, c, p) {
+    const u = /* @__PURE__ */ new Map();
+    if (p)
+      for (const n of p) {
+        const T = a(n.type, {
+          id: n.id,
+          ...n.attributes
+        });
+        u.set(n.id, T);
+      }
+    const f = c.map(
+      (n) => a(t, {
+        id: n.id,
+        ...n.attributes
+      })
+    ), l = /* @__PURE__ */ new Map();
+    for (const n of f)
+      l.set(n.id, n);
+    function h(n) {
+      const T = l.get(n.id) ?? u.get(n.id);
+      if (!T) throw new Error("Unexpected not found record");
+      if (!n.relationships) return;
+      const O = i.get(n.type);
+      if (O)
+        for (const [g, E] of Object.entries(n.relationships)) {
+          const D = s(g), M = O[D];
+          if (!M) continue;
+          const P = (M.relationshipType === 0 ? E.data : [E.data]).filter((v) => v && v.type === M.type).map((v) => u.get(v.id) || l.get(v.id)).filter(Boolean);
+          j(T, D, M.relationshipType === 0 ? P : P[0]);
         }
     }
-    return f && (n.map(M), f.map(M)), u;
+    return p && (c.forEach(h), p.forEach(h)), f;
   }
-  async function A(e, n, f) {
-    const w = h(e), p = await r.fetchDocument(w, void 0, n, f), u = p.data, g = T(e, u, p.included);
-    return { doc: p, records: g };
+  async function m(t, c, p) {
+    const u = await r.fetchDocument(t, void 0, c, p), f = u.data, l = y(t, f, u.included);
+    return { doc: u, records: l };
   }
-  async function B(e, n, f, w) {
-    const p = h(e), u = await r.fetchDocument(p, n, f, w), g = u.data, s = T(e, [g], u.included)[0];
-    if (!s) throw new Error(`Record with id ${n} not found`);
-    return s;
+  async function w(t, c, p, u) {
+    const f = await r.fetchDocument(t, c, p, u), l = f.data, n = y(t, [l], f.included)[0];
+    if (!n) throw new Error(`Record with id ${c} not found`);
+    return n;
   }
-  async function C(e, n, f, w) {
-    const p = e.constructor, u = h(p), g = o.get(p);
-    if (!g) throw new Error(`Model ${p.name} has no relationships`);
-    const M = g[n];
-    if (!M) throw new Error(`Has many relationship ${n} not defined`);
-    if (M.type === 1) {
-      const b = await r.fetchBelongsTo(u, e.id, n, f, w), $ = b.data, v = l(M.ctor, $.id, $.attributes);
-      return e[n] = v, b;
+  async function $(t, c, p, u) {
+    const f = A(t);
+    if (!f) throw new Error("Record type not found - ensure records are created via createRecord");
+    const l = i.get(f);
+    if (!l) throw new Error(`Model ${f} has no relationships`);
+    const h = l[c];
+    if (!h) throw new Error(`Relationship ${c} not defined`);
+    if (h.relationshipType === 1) {
+      const g = await r.fetchBelongsTo(f, t.id, c, p, u), E = g.data, D = a(h.type, {
+        id: E.id,
+        ...E.attributes
+      });
+      return j(t, c, D), g;
     }
-    const s = await r.fetchHasMany(u, e.id, n, f, w), j = (M.type === 0 ? s.data : [s.data]).map((b) => l(M.ctor, b.id, b.attributes));
-    return e[n] = M.type === 0 ? j : j[0], s;
-  }
-  async function S(e) {
-    const n = h(e.constructor), f = {
-      id: e.id,
-      type: n,
-      attributes: e
+    const n = await r.fetchHasMany(f, t.id, c, p, u), O = (h.relationshipType === 0 ? n.data : [n.data]).map((g) => a(h.type, {
+      id: g.id,
+      ...g.attributes
+    }));
+    return j(t, c, h.relationshipType === 0 ? O : O[0]), n;
+  }
+  async function U(t) {
+    const c = A(t);
+    if (!c) throw new Error("Record type not found - ensure records are created via createRecord");
+    const p = {
+      id: t.id,
+      type: c,
+      attributes: t
     };
-    await r.post(f);
+    await r.post(p);
   }
   return {
-    modelRegistry: c,
-    relsRegistry: o,
-    findAll: A,
-    findRecord: B,
-    findRelated: C,
-    saveRecord: S
+    findAll: m,
+    findRecord: w,
+    findRelated: $,
+    createRecord: a,
+    saveRecord: U
   };
 }
 export {
-  q as Model,
-  J as RelationshipType,
-  F as camel,
-  I as useJsonApi
+  B as RelationshipType,
+  H as camel,
+  C as useJsonApi
 };
 //# sourceMappingURL=lib.js.map