yayson 3.0.0 → 4.1.0

package/build/yayson-l2JKseMH.cjs

@@ -0,0 +1,468 @@
+const require_symbols = require('./symbols-nFs99aEX.cjs');
+
+//#region src/yayson/adapters/sequelize.ts
+function isSequelizeModel(model) {
+	return model != null && typeof model === "object" && "get" in model && typeof model.get === "function";
+}
+var SequelizeAdapter = class extends require_symbols.adapter_default {
+	static get(model, key) {
+		if (isSequelizeModel(model)) return model.get(key);
+	}
+	static id(model) {
+		const pkFields = model.constructor && "primaryKeys" in model.constructor ? Object.keys(model.constructor.primaryKeys) : ["id"];
+		if (pkFields.length > 1) throw new Error("YAYSON does not support Sequelize models with composite primary keys. You can only use one column for your primary key. Currently using: " + pkFields.join(","));
+		else if (pkFields.length < 1) throw new Error("YAYSON can only serialize Sequelize models which have a primary key. This is used for the JSON:API model id.");
+		const id = this.get(model, pkFields[0]);
+		if (id == null) return;
+		return `${id}`;
+	}
+};
+var sequelize_default = SequelizeAdapter;
+
+//#endregion
+//#region src/yayson/utils.ts
+/**
+* Filters an attributes object to only include keys in the fields array.
+* Returns the original attributes if fields is undefined.
+*/
+function filterByFields(attributes, fields) {
+	if (!fields) return attributes;
+	const filtered = {};
+	for (const key of fields) if (key in attributes) filtered[key] = attributes[key];
+	return filtered;
+}
+
+//#endregion
+//#region src/yayson/presenter.ts
+function buildLinks(link) {
+	if (link == null) return;
+	if (typeof link === "object" && (link.self != null || link.related != null)) return link;
+	else return { self: String(link) };
+}
+function createPresenter(adapter) {
+	class Presenter {
+		static adapter = adapter;
+		static type = "objects";
+		static fields;
+		scope;
+		constructor(scope) {
+			this.scope = scope ?? { data: null };
+		}
+		id(instance) {
+			return this.constructor.adapter.id(instance);
+		}
+		selfLinks(_instance) {}
+		links(_instance) {}
+		relationships() {
+			return {};
+		}
+		attributes(instance) {
+			if (instance == null) return {};
+			const attributes = { ...this.constructor.adapter.get(instance) };
+			delete attributes["id"];
+			const relationships = this.relationships();
+			if (relationships) for (const key in relationships) delete attributes[key];
+			return filterByFields(attributes, this.constructor.fields);
+		}
+		includeRelationships(scope, instance) {
+			const relationships = this.relationships();
+			const result = [];
+			if (!relationships) return result;
+			for (const key in relationships) {
+				const factory = relationships[key];
+				if (!factory) throw new Error(`Presenter for ${key} in ${this.constructor.type} is not defined`);
+				const presenter = new factory(scope);
+				const data = this.constructor.adapter.get(instance, key);
+				result.push(presenter.toJSON(data, { include: true }));
+			}
+			return result;
+		}
+		buildRelationships(instance) {
+			if (instance == null) return null;
+			const rels = this.relationships();
+			const links = this.links(instance) || {};
+			let relationships = null;
+			if (!rels) return null;
+			for (const key in rels) {
+				const data = this.constructor.adapter.get(instance, key);
+				const presenter = rels[key];
+				const buildData = (d) => {
+					const id = this.constructor.adapter.id(d);
+					if (!id) throw new Error(`Model of type ${presenter.type} is missing an id (relationship '${key}' of ${this.constructor.type})`);
+					return {
+						id,
+						type: presenter.type
+					};
+				};
+				const build = (d) => {
+					const rel = {};
+					if (d != null) rel.data = buildData(d);
+					if (links[key] != null) rel.links = buildLinks(links[key]);
+					else if (d == null) rel.data = null;
+					return rel;
+				};
+				if (!relationships) relationships = {};
+				if (!relationships[key]) relationships[key] = {};
+				if (Array.isArray(data)) {
+					relationships[key].data = data.map(buildData);
+					if (links[key] != null) relationships[key].links = buildLinks(links[key]);
+				} else relationships[key] = build(data);
+			}
+			return relationships;
+		}
+		buildSelfLink(instance) {
+			return buildLinks(this.selfLinks(instance));
+		}
+		toJSON(instanceOrCollection, options) {
+			const opts = options ?? {};
+			if (opts.meta != null) this.scope.meta = opts.meta;
+			if (opts.links != null) this.scope.links = opts.links;
+			if (!this.scope.data) this.scope.data = null;
+			if (instanceOrCollection == null) return this.scope;
+			if (Array.isArray(instanceOrCollection)) {
+				const collection = instanceOrCollection;
+				if (!this.scope.data) this.scope.data = [];
+				collection.forEach((instance) => {
+					return this.toJSON(instance, options);
+				});
+			} else {
+				const instance = instanceOrCollection;
+				let added = true;
+				const model = {
+					id: this.id(instance),
+					type: this.constructor.type,
+					attributes: this.attributes(instance)
+				};
+				if (model.id === void 0) delete model.id;
+				const relationships = this.buildRelationships(instance);
+				if (relationships != null) model.relationships = relationships;
+				const links = this.buildSelfLink(instance);
+				if (links != null) model.links = links;
+				if (opts.include) {
+					if (!this.scope.included) this.scope.included = [];
+					if (!(this.scope.included || []).concat(Array.isArray(this.scope.data) ? this.scope.data : this.scope.data ? [this.scope.data] : []).some((i) => i.id === model.id && i.type === model.type)) this.scope.included.push(model);
+					else added = false;
+				} else if (this.scope.data != null) if (Array.isArray(this.scope.data)) if (!this.scope.data.some((i) => i.id === model.id && i.type === model.type)) this.scope.data.push(model);
+				else added = false;
+				else this.scope.data = model;
+				else this.scope.data = model;
+				if (added) this.includeRelationships(this.scope, instance);
+			}
+			return this.scope;
+		}
+		payload(instance, options) {
+			if (Array.isArray(instance)) throw new Error("payload() expects a single resource, not an array");
+			if (instance == null) throw new Error("payload() requires a resource, got null");
+			const model = {
+				type: this.constructor.type,
+				attributes: this.attributes(instance)
+			};
+			const id = this.id(instance);
+			if (id != null) model.id = id;
+			const relationships = this.buildRelationships(instance);
+			if (relationships != null) model.relationships = relationships;
+			const result = { data: model };
+			const opts = options ?? {};
+			if (opts.meta != null) result.meta = opts.meta;
+			if (opts.links != null) result.links = opts.links;
+			return result;
+		}
+		render(instanceOrCollection, options) {
+			return this.toJSON(instanceOrCollection, options);
+		}
+		static toJSON(instanceOrCollection, options) {
+			return new this().toJSON(instanceOrCollection, options);
+		}
+		static render(instanceOrCollection, options) {
+			return new this().render(instanceOrCollection, options);
+		}
+		static payload(instance, options) {
+			return new this().payload(instance, options);
+		}
+	}
+	return Presenter;
+}
+
+//#endregion
+//#region src/yayson/schema.ts
+function isZodLikeSchema(schema) {
+	return schema != null && typeof schema === "object" && "parse" in schema && typeof schema.parse === "function" && "safeParse" in schema && typeof schema.safeParse === "function";
+}
+function validate(schema, data, strict) {
+	if (!isZodLikeSchema(schema)) throw new Error("Invalid schema: must have parse and safeParse methods");
+	if (strict) return {
+		valid: true,
+		data: schema.parse(data)
+	};
+	else {
+		const result = schema.safeParse(data);
+		if (result.success) return {
+			valid: true,
+			data: result.data
+		};
+		else return {
+			valid: false,
+			data,
+			error: result.error
+		};
+	}
+}
+
+//#endregion
+//#region src/yayson/store.ts
+function hasId(model) {
+	return model.id != null;
+}
+var StoreRecord = class {
+	id;
+	type;
+	attributes;
+	relationships;
+	links;
+	meta;
+	constructor(options) {
+		this.id = options.id;
+		this.type = options.type;
+		this.attributes = options.attributes;
+		this.relationships = options.relationships;
+		this.links = options.links;
+		this.meta = options.meta;
+	}
+};
+var Store = class Store {
+	records = [];
+	schemas;
+	strict;
+	validationErrors = [];
+	constructor(options) {
+		this.schemas = options?.schemas;
+		this.strict = options?.strict ?? false;
+		this.reset();
+	}
+	reset() {
+		this.records = [];
+		this.validationErrors = [];
+	}
+	#createStub(type, id) {
+		const stub = { id };
+		stub[require_symbols.TYPE] = type;
+		return stub;
+	}
+	#createModel(resource, options) {
+		const models = options?.models ?? {};
+		const model = { ...resource.attributes || {} };
+		if (resource.id != null) model.id = resource.id;
+		const type = resource.type;
+		model[require_symbols.TYPE] = type;
+		if (resource.meta != null) model[require_symbols.META] = resource.meta;
+		if (resource.links != null) model[require_symbols.LINKS] = resource.links;
+		if (hasId(model)) {
+			const idStr = String(model.id);
+			if (!models[type]) models[type] = {};
+			if (!models[type][idStr]) models[type][idStr] = model;
+		}
+		if (resource.relationships != null) {
+			const resolver = (ref) => {
+				return this.#findModel(ref.type, ref.id, models) ?? this.#createStub(ref.type, ref.id);
+			};
+			this.#resolveRelationships(model, resource.relationships, resolver, { includeRelMeta: options?.includeRelMeta });
+		}
+		return model;
+	}
+	#resolveRelationships(model, relationships, resolver, options) {
+		const includeRelMeta = options?.includeRelMeta ?? true;
+		for (const key in relationships) {
+			const { data, links, meta } = relationships[key];
+			model[key] = null;
+			if (data == null && links == null) continue;
+			if (Array.isArray(data)) model[key] = data.filter((item) => item.id != null).map(resolver);
+			else if (data != null && data.id != null) {
+				const relModel = resolver(data);
+				if (includeRelMeta) {
+					const modelWithMeta = relModel;
+					modelWithMeta[require_symbols.REL_LINKS] = links || {};
+					modelWithMeta[require_symbols.REL_META] = meta || {};
+				}
+				model[key] = relModel;
+			} else if (data == null && (links != null || meta != null) && includeRelMeta) {
+				const relModel = { id: "" };
+				relModel[require_symbols.REL_LINKS] = links || {};
+				relModel[require_symbols.REL_META] = meta || {};
+				model[key] = relModel;
+			}
+		}
+	}
+	toModel(rec, type, models) {
+		const model = this.#createModel(rec, { models });
+		if (this.schemas && this.schemas[rec.type]) {
+			const schema = this.schemas[rec.type];
+			const result = validate(schema, model, this.strict);
+			if (!result.valid) this.validationErrors.push({
+				type: rec.type,
+				id: rec.id,
+				error: result.error
+			});
+			const validatedModel = result.data;
+			validatedModel[require_symbols.TYPE] = model[require_symbols.TYPE];
+			validatedModel[require_symbols.LINKS] = model[require_symbols.LINKS];
+			validatedModel[require_symbols.META] = model[require_symbols.META];
+			return validatedModel;
+		}
+		return model;
+	}
+	findRecord(type, id) {
+		const idStr = String(id);
+		return this.records.find((r) => r.type === type && String(r.id) === idStr);
+	}
+	findRecords(type) {
+		return this.records.filter((r) => r.type === type);
+	}
+	#findModel(type, id, models) {
+		const idStr = String(id);
+		const cached = models[type]?.[idStr];
+		if (cached) return cached;
+		const rec = this.findRecord(type, id);
+		if (rec == null) return null;
+		return this.toModel(rec, type, models);
+	}
+	find(type, id, models) {
+		return this.#findModel(type, id, models ?? {});
+	}
+	findAll(type, models) {
+		const modelsObj = models ?? {};
+		const recs = this.findRecords(type);
+		if (recs == null) return [];
+		recs.forEach((rec) => {
+			if (!modelsObj[type]) modelsObj[type] = {};
+			return this.toModel(rec, type, modelsObj);
+		});
+		return Object.values(modelsObj[type] || {});
+	}
+	remove(type, id) {
+		const removeOne = (record) => {
+			const index = this.records.indexOf(record);
+			if (!(index < 0)) this.records.splice(index, 1);
+		};
+		if (id != null) {
+			const record = this.findRecord(type, String(id));
+			if (record) removeOne(record);
+		} else this.findRecords(type).forEach(removeOne);
+	}
+	syncAll(body) {
+		this.validationErrors = [];
+		const previousRecords = [...this.records];
+		const syncData = (data) => {
+			if (data == null) return [];
+			const add = (obj) => {
+				const { type, id } = obj;
+				this.remove(type, id);
+				const rec = new StoreRecord(obj);
+				this.records.push(rec);
+				return rec;
+			};
+			if (Array.isArray(data)) return data.map((item) => {
+				if (!item.id) throw new Error(`Resource of type ${item.type} is missing an id`);
+				return add({
+					...item,
+					attributes: item.attributes ?? void 0,
+					relationships: item.relationships ?? void 0,
+					id: item.id
+				});
+			});
+			else {
+				if (!data.id) throw new Error(`Resource of type ${data.type} is missing an id`);
+				return [add({
+					...data,
+					attributes: data.attributes ?? void 0,
+					relationships: data.relationships ?? void 0,
+					id: data.id
+				})];
+			}
+		};
+		try {
+			syncData(body.included);
+			const recs = syncData(body.data);
+			const models = {};
+			const result = recs.map((rec) => this.toModel(rec, rec.type, models));
+			if (body.meta != null) result[require_symbols.META] = body.meta;
+			return result;
+		} catch (e) {
+			this.records = previousRecords;
+			throw e;
+		}
+	}
+	sync(body) {
+		const result = this.syncAll(body);
+		if (!Array.isArray(body.data) && body.data != null) {
+			const model = result[0];
+			if (result[require_symbols.META]) model[require_symbols.META] = result[require_symbols.META];
+			return model;
+		}
+		return result;
+	}
+	/**
+	* Build a model from a JSON:API document without storing it.
+	* Useful for create payloads where id may be absent.
+	*
+	* Per JSON:API spec: "The id member is not required when the resource object
+	* originates at the client and represents a new resource to be created on the server."
+	*/
+	static build(body) {
+		return new Store().build(body);
+	}
+	build(body) {
+		const { data } = body;
+		if (data == null || Array.isArray(data)) throw new Error("build() expects a single resource in data, not null or an array");
+		return this.#createModel(data);
+	}
+	retrieve(type, body) {
+		const synced = this.syncAll(body);
+		const model = synced.find((m) => m[require_symbols.TYPE] === type);
+		if (!model) return null;
+		if (synced[require_symbols.META]) model[require_symbols.META] = synced[require_symbols.META];
+		return model;
+	}
+	retrieveAll(type, body) {
+		const synced = this.syncAll(body);
+		const result = synced.filter((model) => model[require_symbols.TYPE] === type);
+		result[require_symbols.META] = synced[require_symbols.META];
+		return result;
+	}
+};
+
+//#endregion
+//#region src/yayson.ts
+function lookupAdapter(nameOrAdapter) {
+	if (nameOrAdapter === "default" || !nameOrAdapter) return require_symbols.adapter_default;
+	else if (typeof nameOrAdapter === "string") if (nameOrAdapter === "sequelize") return sequelize_default;
+	else throw new Error("Adapter not found: " + nameOrAdapter);
+	return nameOrAdapter;
+}
+function yayson(options) {
+	return {
+		Store,
+		Presenter: createPresenter(lookupAdapter(options?.adapter)),
+		Adapter: require_symbols.adapter_default
+	};
+}
+var yayson_default = yayson;
+
+//#endregion
+Object.defineProperty(exports, 'filterByFields', {
+  enumerable: true,
+  get: function () {
+    return filterByFields;
+  }
+});
+Object.defineProperty(exports, 'validate', {
+  enumerable: true,
+  get: function () {
+    return validate;
+  }
+});
+Object.defineProperty(exports, 'yayson_default', {
+  enumerable: true,
+  get: function () {
+    return yayson_default;
+  }
+});

package/build/yayson.cjs

@@ -0,0 +1,3 @@
+const require_yayson = require('./yayson-l2JKseMH.cjs');
+
+module.exports = require_yayson.yayson_default;

package/build/yayson.d.cts

@@ -0,0 +1,3 @@
+import { T as Adapter, a as JsonApiRelationship, d as SchemaRegistry, h as StoreOptions, i as JsonApiLinks, l as LegacyStoreOptions, n as JsonApiDocument, o as JsonApiRelationships, r as JsonApiLink, s as JsonApiResource, u as PresenterOptions, v as ValidationError, y as ZodLikeSchema } from "./types-NiKV-lj-.cjs";
+import { n as YaysonResult, r as yayson, t as YaysonOptions } from "./yayson-3UYKq2H5.cjs";
+export { Adapter, JsonApiDocument, JsonApiLink, JsonApiLinks, JsonApiRelationship, JsonApiRelationships, JsonApiResource, LegacyStoreOptions, PresenterOptions, SchemaRegistry, StoreOptions, ValidationError, YaysonOptions, YaysonResult, ZodLikeSchema, yayson as default };

package/build/yayson.d.mts

@@ -0,0 +1,3 @@
+import { T as Adapter, a as JsonApiRelationship, d as SchemaRegistry, h as StoreOptions, i as JsonApiLinks, l as LegacyStoreOptions, n as JsonApiDocument, o as JsonApiRelationships, r as JsonApiLink, s as JsonApiResource, u as PresenterOptions, v as ValidationError, y as ZodLikeSchema } from "./types-Do2flKZX.mjs";
+import { n as YaysonResult, r as yayson, t as YaysonOptions } from "./yayson-Ce5uGpgU.mjs";
+export { Adapter, JsonApiDocument, JsonApiLink, JsonApiLinks, JsonApiRelationship, JsonApiRelationships, JsonApiResource, LegacyStoreOptions, PresenterOptions, SchemaRegistry, StoreOptions, ValidationError, YaysonOptions, YaysonResult, ZodLikeSchema, yayson as default };

package/build/yayson.mjs

@@ -0,0 +1,3 @@
+import { t as yayson_default } from "./yayson-CwZg5FNt.mjs";
+
+export { yayson_default as default };

package/package.json

@@ -1,19 +1,63 @@
 {
   "name": "yayson",
-  "version": "3.0.0",
+  "version": "4.1.0",
   "description": "A library for serializing and reading JSON API standardized data in JavaScript.",
-  "main": "src/yayson.js",
+  "type": "module",
+  "main": "./build/yayson.cjs",
+  "module": "./build/yayson.mjs",
+  "types": "./build/yayson.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./build/yayson.d.mts",
+        "default": "./build/yayson.mjs"
+      },
+      "require": {
+        "types": "./build/yayson.d.cts",
+        "default": "./build/yayson.cjs"
+      }
+    },
+    "./legacy": {
+      "import": {
+        "types": "./build/legacy.d.mts",
+        "default": "./build/legacy.mjs"
+      },
+      "require": {
+        "types": "./build/legacy.d.cts",
+        "default": "./build/legacy.cjs"
+      }
+    },
+    "./utils": {
+      "import": {
+        "types": "./build/utils.d.mts",
+        "default": "./build/utils.mjs"
+      },
+      "require": {
+        "types": "./build/utils.d.cts",
+        "default": "./build/utils.cjs"
+      }
+    }
+  },
+  "files": [
+    "build/**/*",
+    "skill/**/*",
+    "README.md",
+    "LICENSE"
+  ],
   "engines": {
-    "node": ">=14",
-    "npm": ">=6"
+    "node": ">=20",
+    "npm": ">=10"
   },
   "scripts": {
-    "test": "mocha",
-    "build": "webpack --config webpack.dist.js",
-    "test-browser": "webpack-dev-server --config webpack.browser.js",
-    "preversion": "npm test && npm run build && git add dist/yayson.js",
+    "test": "tsx node_modules/.bin/mocha",
+    "test:build": "node test/build.test.cjs",
+    "build": "tsdown",
+    "prepublishOnly": "npm run build && npm run test:build",
+    "preversion": "npm test && npm run build && npm run test:build",
     "postversion": "git push --follow-tags origin master",
-    "release": "npm version minor"
+    "release": "npm version minor",
+    "format": "prettier --write src test",
+    "lint": "concurrently --prefix '[{name}]' --prefix-colors '#f73fae,#00c2db,#00db8b' --names 'tsc,eslint,prettier' 'tsc --noEmit' 'eslint .' 'prettier --check .'"
   },
   "repository": {
     "type": "git",
@@ -37,26 +81,26 @@
     "url": "https://github.com/confetti/yayson/issues"
   },
   "homepage": "https://github.com/confetti/yayson",
-  "browserslist": [
-    "defaults",
-    "not IE 11"
-  ],
   "devDependencies": {
-    "@babel/core": "^7.20.12",
-    "@babel/eslint-parser": "^7.19.1",
-    "@babel/preset-env": "^7.20.2",
-    "babel-loader": "^9.1.2",
-    "chai": "^4.3.7",
-    "core-js": "^3.27.2",
-    "eslint": "^8.33.0",
-    "eslint-plugin-mocha": "^10.1.0",
-    "mocha": "^10.2.0",
-    "prettier": "^2.8.3",
-    "sinon": "^15.0.1",
+    "@eslint-community/eslint-plugin-eslint-comments": "4.6.0",
+    "@eslint/js": "^9.35.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.5.1",
+    "@types/sinon": "^17.0.4",
+    "@types/sinon-chai": "^4.0.0",
+    "chai": "^4.5.0",
+    "concurrently": "^9.2.1",
+    "eslint": "9.39.1",
+    "eslint-plugin-mocha": "^11.1.0",
+    "globals": "^16.4.0",
+    "mocha": "^11.7.2",
+    "prettier": "3.7.2",
+    "sinon": "^21.0.0",
     "sinon-chai": "^3.7.0",
-    "webpack": "^5.75.0",
-    "webpack-cli": "^5.0.1",
-    "webpack-dev-server": "^4.11.1",
-    "webpack-merge": "^5.8.0"
+    "tsdown": "0.20.0-beta.4",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.44.0",
+    "zod": "4.3.5"
   }
 }