@byearlybird/starling 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -14,19 +14,20 @@ declare namespace value_d_exports {
   export { EncodedValue, decode$3 as decode, encode$3 as encode, isEncoded, merge$2 as merge };
 }
 type EncodedValue<T$1> = {
-  __value: T$1;
-  __eventstamp: string;
+  "~value": T$1;
+  "~eventstamp": string;
 };
 declare const encode$3: <T>(value: T, eventstamp: string) => EncodedValue<T>;
 declare const decode$3: <T>(value: EncodedValue<T>) => T;
 declare const merge$2: <T>(into: EncodedValue<T>, from: EncodedValue<T>) => EncodedValue<T>;
 declare const isEncoded: (value: unknown) => boolean;
 declare namespace record_d_exports {
-  export { EncodedRecord, decode$2 as decode, encode$2 as encode, merge$1 as merge };
+  export { EncodedRecord, decode$2 as decode, encode$2 as encode, isObject, merge$1 as merge };
 }
 type EncodedRecord = {
   [key: string]: EncodedValue<unknown> | EncodedRecord;
 };
+declare const isObject: (value: unknown) => boolean;
 declare const encode$2: <T extends Record<string, unknown>>(obj: T, eventstamp: string) => EncodedRecord;
 declare const decode$2: <T extends Record<string, unknown>>(obj: EncodedRecord) => T;
 declare const merge$1: (into: EncodedRecord, from: EncodedRecord) => EncodedRecord;
@@ -35,11 +36,11 @@ declare namespace document_d_exports {
 }
 type EncodedDocument = {
   "~id": string;
-  "~data": EncodedRecord;
+  "~data": EncodedValue<unknown> | EncodedRecord;
   "~deletedAt": string | null;
 };
-declare const encode$1: <T extends record_d_exports<string, unknown>>(id: string, obj: T, eventstamp: string, deletedAt?: string | null) => EncodedDocument;
-declare const decode$1: <T extends record_d_exports<string, unknown>>(doc: EncodedDocument) => {
+declare const encode$1: <T>(id: string, obj: T, eventstamp: string, deletedAt?: string | null) => EncodedDocument;
+declare const decode$1: <T>(doc: EncodedDocument) => {
   "~id": string;
   "~data": T;
   "~deletedAt": string | null;
@@ -74,86 +75,70 @@ declare const create$1: (iterable?: Iterable<readonly [string, EncodedDocument]>
   };
 };
 declare namespace store_d_exports {
-  export { Plugin, PluginHandle, PluginMethods, Store as StarlingStore, StoreHooks, StoreOnBeforeDelete, StoreOnBeforePatch, StoreOnBeforePut, StoreOnDelete, StoreOnPatch, StoreOnPut, StoreTransaction, create };
+  export { DeepPartial, NotPromise, Plugin, PluginMethods, Store as StarlingStore, StoreHooks, StoreOnDelete, StoreOnPatch, StoreOnPut, StorePutOptions, StoreSetTransaction, create };
 }
 type DeepPartial<T$1> = T$1 extends object ? { [P in keyof T$1]?: DeepPartial<T$1[P]> } : T$1;
+/**
+ * Type constraint to prevent Promise returns from set callbacks.
+ * Transactions must be synchronous operations.
+ */
+type NotPromise<T$1> = T$1 extends Promise<any> ? never : T$1;
 /**
  * Called once per commit with all put operations accumulated as decoded entries.
  * Only fires if at least one put occurred.
  */
-type StoreOnPut<T$1 extends Record<string, unknown>> = (entries: ReadonlyArray<readonly [string, T$1]>) => void;
+type StoreOnPut<T$1> = (entries: ReadonlyArray<readonly [string, T$1]>) => void;
 /**
  * Called once per commit with all patch operations accumulated as decoded entries.
  * Only fires if at least one patch occurred.
  */
-type StoreOnPatch<T$1 extends Record<string, unknown>> = (entries: ReadonlyArray<readonly [string, T$1]>) => void;
+type StoreOnPatch<T$1> = (entries: ReadonlyArray<readonly [string, T$1]>) => void;
 /**
  * Called once per commit with all deleted keys (IDs).
  * Only fires if at least one delete occurred.
  */
 type StoreOnDelete = (keys: ReadonlyArray<string>) => void;
-/**
- * Called before a put operation is applied.
- * Throws to reject the operation.
- */
-type StoreOnBeforePut<T$1 extends Record<string, unknown>> = (key: string, value: T$1) => void;
-/**
- * Called before a patch operation is applied.
- * Throws to reject the operation.
- */
-type StoreOnBeforePatch<T$1 extends Record<string, unknown>> = (key: string, value: DeepPartial<T$1>) => void;
-/**
- * Called before a delete operation is applied.
- * Throws to reject the operation.
- */
-type StoreOnBeforeDelete = (key: string) => void;
 /**
  * Hook callbacks that receive batches of decoded entries.
  * Hooks fire on commit only, never during staged operations.
  * Arrays are readonly to prevent external mutation.
  */
-type StoreHooks<T$1 extends Record<string, unknown>> = {
-  onBeforePut?: StoreOnBeforePut<T$1>;
-  onBeforePatch?: StoreOnBeforePatch<T$1>;
-  onBeforeDelete?: StoreOnBeforeDelete;
+type StoreHooks<T$1> = {
   onPut?: StoreOnPut<T$1>;
   onPatch?: StoreOnPatch<T$1>;
   onDelete?: StoreOnDelete;
 };
-type StoreTransaction<T$1 extends Record<string, unknown>> = {
-  put: (key: string, value: T$1) => void;
+type StorePutOptions = {
+  withId?: string;
+};
+type StoreSetTransaction<T$1> = {
+  put: (value: T$1, options?: StorePutOptions) => string;
   patch: (key: string, value: DeepPartial<T$1>) => void;
   merge: (doc: EncodedDocument) => void;
   del: (key: string) => void;
-  has: (key: string) => boolean;
-  commit: (opts?: {
-    silent: boolean;
-  }) => void;
+  get: (key: string) => T$1 | null;
   rollback: () => void;
 };
 type PluginMethods = Record<string, (...args: any[]) => any>;
-type PluginHandle<T$1 extends Record<string, unknown>, M$1 extends PluginMethods = {}> = {
-  init: () => Promise<void> | void;
+type Plugin<T$1, M$1 extends PluginMethods = {}> = {
+  init: (store: Store<T$1>) => Promise<void> | void;
   dispose: () => Promise<void> | void;
   hooks?: StoreHooks<T$1>;
   methods?: M$1;
 };
-type Plugin<T$1 extends Record<string, unknown>, M$1 extends PluginMethods = {}> = (store: Store<T$1, any>) => PluginHandle<T$1, M$1>;
-type Store<T$1 extends Record<string, unknown>, Extended = {}> = {
+type Store<T$1, Extended = {}> = {
   get: (key: string) => T$1 | null;
-  has: (key: string) => boolean;
-  readonly size: number;
-  values: () => IterableIterator<T$1>;
+  set: <R = void>(callback: (tx: StoreSetTransaction<T$1>) => NotPromise<R>, opts?: {
+    silent?: boolean;
+  }) => NotPromise<R>;
   entries: () => IterableIterator<readonly [string, T$1]>;
   snapshot: () => EncodedDocument[];
-  put: (key: string, value: T$1) => void;
-  patch: (key: string, value: DeepPartial<T$1>) => void;
-  del: (key: string) => void;
-  begin: () => StoreTransaction<T$1>;
   use: <M extends PluginMethods>(plugin: Plugin<T$1, M>) => Store<T$1, Extended & M>;
   init: () => Promise<Store<T$1, Extended>>;
   dispose: () => Promise<void>;
 } & Extended;
-declare const create: <T extends Record<string, unknown>>() => Store<T, {}>;
+declare const create: <T>(config?: {
+  getId?: () => string;
+}) => Store<T, {}>;
 //#endregion
 export { type clock_d_exports as Clock, document_d_exports as Document, eventstamp_d_exports as Eventstamp, kv_d_exports as KV, record_d_exports as Record, store_d_exports as Store, value_d_exports as Value };

package/dist/index.js

@@ -20,8 +20,8 @@ const decode$3 = (eventstamp) => {
 
 //#endregion
 //#region src/clock.ts
-var clock_exports = /* @__PURE__ */ __export({ create: () => create });
-const create = () => {
+var clock_exports = /* @__PURE__ */ __export({ create: () => create$2 });
+const create$2 = () => {
 	let counter = 0;
 	let lastMs = Date.now();
 	return {
@@ -56,21 +56,22 @@ var value_exports = /* @__PURE__ */ __export({
 	merge: () => merge$2
 });
 const encode$2 = (value, eventstamp) => ({
-	__value: value,
-	__eventstamp: eventstamp
+	"~value": value,
+	"~eventstamp": eventstamp
 });
-const decode$2 = (value) => value.__value;
+const decode$2 = (value) => value["~value"];
 const merge$2 = (into, from) => ({
-	__value: into.__eventstamp > from.__eventstamp ? into.__value : from.__value,
-	__eventstamp: into.__eventstamp > from.__eventstamp ? into.__eventstamp : from.__eventstamp
+	"~value": into["~eventstamp"] > from["~eventstamp"] ? into["~value"] : from["~value"],
+	"~eventstamp": into["~eventstamp"] > from["~eventstamp"] ? into["~eventstamp"] : from["~eventstamp"]
 });
-const isEncoded = (value) => !!(typeof value === "object" && value !== null && "__value" in value && "__eventstamp" in value);
+const isEncoded = (value) => !!(typeof value === "object" && value !== null && "~value" in value && "~eventstamp" in value);
 
 //#endregion
 //#region src/record.ts
 var record_exports = /* @__PURE__ */ __export({
 	decode: () => decode$1,
 	encode: () => encode$1,
+	isObject: () => isObject,
 	merge: () => merge$1
 });
 const isObject = (value) => !!(value != null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype);
@@ -139,19 +140,26 @@ var document_exports = /* @__PURE__ */ __export({
 });
 const encode = (id, obj, eventstamp, deletedAt = null) => ({
 	"~id": id,
-	"~data": encode$1(obj, eventstamp),
+	"~data": isObject(obj) ? encode$1(obj, eventstamp) : encode$2(obj, eventstamp),
 	"~deletedAt": deletedAt
 });
 const decode = (doc) => ({
 	"~id": doc["~id"],
-	"~data": decode$1(doc["~data"]),
+	"~data": isEncoded(doc["~data"]) ? decode$2(doc["~data"]) : decode$1(doc["~data"]),
 	"~deletedAt": doc["~deletedAt"]
 });
-const merge = (into, from) => ({
-	"~id": into["~id"],
-	"~data": merge$1(into["~data"], from["~data"]),
-	"~deletedAt": into["~deletedAt"] && from["~deletedAt"] ? into["~deletedAt"] > from["~deletedAt"] ? into["~deletedAt"] : from["~deletedAt"] : into["~deletedAt"] || from["~deletedAt"] || null
-});
+const merge = (into, from) => {
+	const intoIsValue = isEncoded(into["~data"]);
+	const fromIsValue = isEncoded(from["~data"]);
+	if (intoIsValue !== fromIsValue) throw new Error(`Cannot merge documents with incompatible types: ${intoIsValue ? "primitive" : "object"} vs ${fromIsValue ? "primitive" : "object"}`);
+	const mergedData = intoIsValue && fromIsValue ? merge$2(into["~data"], from["~data"]) : merge$1(into["~data"], from["~data"]);
+	const mergedDeletedAt = into["~deletedAt"] && from["~deletedAt"] ? into["~deletedAt"] > from["~deletedAt"] ? into["~deletedAt"] : from["~deletedAt"] : into["~deletedAt"] || from["~deletedAt"] || null;
+	return {
+		"~id": into["~id"],
+		"~data": mergedData,
+		"~deletedAt": mergedDeletedAt
+	};
+};
 const del = (doc, eventstamp) => ({
 	...doc,
 	"~deletedAt": eventstamp
@@ -159,8 +167,8 @@ const del = (doc, eventstamp) => ({
 
 //#endregion
 //#region src/kv.ts
-var kv_exports = /* @__PURE__ */ __export({ create: () => create$2 });
-const create$2 = (iterable) => {
+var kv_exports = /* @__PURE__ */ __export({ create: () => create$1 });
+const create$1 = (iterable) => {
 	let readMap = new Map(iterable);
 	function cloneMap(src) {
 		return new Map(src);
@@ -217,21 +225,19 @@ const create$2 = (iterable) => {
 
 //#endregion
 //#region src/store.ts
-var store_exports = /* @__PURE__ */ __export({ create: () => create$1 });
-const create$1 = () => {
-	const clock = create();
+var store_exports = /* @__PURE__ */ __export({ create: () => create });
+const create = (config = {}) => {
+	const kv = create$1();
+	const clock = create$2();
+	const initializers = /* @__PURE__ */ new Set();
+	const disposers = /* @__PURE__ */ new Set();
+	const getId = config.getId ?? (() => crypto.randomUUID());
 	const encodeValue = (key, value) => encode(key, value, clock.now());
-	const kv = create$2();
 	const listeners = {
-		beforePut: /* @__PURE__ */ new Set(),
-		beforePatch: /* @__PURE__ */ new Set(),
-		beforeDel: /* @__PURE__ */ new Set(),
 		put: /* @__PURE__ */ new Set(),
 		patch: /* @__PURE__ */ new Set(),
 		del: /* @__PURE__ */ new Set()
 	};
-	const initializers = /* @__PURE__ */ new Set();
-	const disposers = /* @__PURE__ */ new Set();
 	const decodeActive = (doc) => {
 		if (!doc || doc["~deletedAt"]) return null;
 		return decode(doc)["~data"];
@@ -240,23 +246,11 @@ const create$1 = () => {
 		get(key) {
 			return decodeActive(kv.get(key));
 		},
-		has(key) {
-			return decodeActive(kv.get(key)) !== null;
-		},
-		values() {
-			function* iterator() {
-				for (const doc of kv.values()) {
-					const data = decodeActive(doc);
-					if (data) yield data;
-				}
-			}
-			return iterator();
-		},
 		entries() {
 			function* iterator() {
 				for (const [key, doc] of kv.entries()) {
 					const data = decodeActive(doc);
-					if (data) yield [key, data];
+					if (data !== null) yield [key, data];
 				}
 			}
 			return iterator();
@@ -264,45 +258,27 @@ const create$1 = () => {
 		snapshot() {
 			return Array.from(kv.values());
 		},
-		get size() {
-			let count = 0;
-			for (const doc of kv.values()) if (doc && !doc["~deletedAt"]) count++;
-			return count;
-		},
-		put(key, value) {
-			const tx = this.begin();
-			tx.put(key, value);
-			tx.commit();
-		},
-		patch(key, value) {
-			const tx = this.begin();
-			tx.patch(key, value);
-			tx.commit();
-		},
-		del(key) {
-			const tx = this.begin();
-			tx.del(key);
-			tx.commit();
-		},
-		begin() {
+		set(callback, opts) {
 			const tx = kv.begin();
+			const silent = opts?.silent ?? false;
 			const putKeyValues = [];
 			const patchKeyValues = [];
 			const deleteKeys = [];
-			return {
-				put(key, value) {
-					for (const fn of listeners.beforePut) fn(key, value);
+			let rolledBack = false;
+			const setTransaction = {
+				put(value, options) {
+					const key = options?.withId ?? getId();
 					tx.put(key, encodeValue(key, value));
 					putKeyValues.push([key, value]);
+					return key;
 				},
 				patch(key, value) {
-					for (const fn of listeners.beforePatch) fn(key, value);
 					tx.patch(key, encode(key, value, clock.now()));
 					const merged = decodeActive(tx.get(key));
 					if (merged) patchKeyValues.push([key, merged]);
 				},
 				merge(doc) {
-					if (tx.has(doc["~id"])) tx.patch(doc["~id"], doc);
+					if (tx.get(doc["~id"])) tx.patch(doc["~id"], doc);
 					else tx.put(doc["~id"], doc);
 					const currentDoc = tx.get(doc["~id"]);
 					if (currentDoc && !currentDoc["~deletedAt"]) {
@@ -311,50 +287,36 @@ const create$1 = () => {
 					}
 				},
 				del(key) {
-					for (const fn of listeners.beforeDel) fn(key);
 					if (!tx.get(key)) return;
 					tx.del(key, clock.now());
 					deleteKeys.push(key);
 				},
-				has(key) {
-					return tx.has(key);
-				},
-				commit(opts = { silent: false }) {
-					tx.commit();
-					if (opts.silent) return;
-					if (putKeyValues.length > 0) for (const fn of listeners.put) fn(Object.freeze([...putKeyValues]));
-					if (patchKeyValues.length > 0) for (const fn of listeners.patch) fn(Object.freeze([...patchKeyValues]));
-					if (deleteKeys.length > 0) for (const fn of listeners.del) fn(Object.freeze([...deleteKeys]));
+				get(key) {
+					return decodeActive(tx.get(key));
 				},
 				rollback() {
+					rolledBack = true;
 					tx.rollback();
 				}
 			};
+			try {
+				const result = callback(setTransaction);
+				if (rolledBack) return result;
+				tx.commit();
+				if (!silent) {
+					if (putKeyValues.length > 0) for (const fn of listeners.put) fn(Object.freeze([...putKeyValues]));
+					if (patchKeyValues.length > 0) for (const fn of listeners.patch) fn(Object.freeze([...patchKeyValues]));
+					if (deleteKeys.length > 0) for (const fn of listeners.del) fn(Object.freeze([...deleteKeys]));
+				}
+				return result;
+			} catch (error) {
+				tx.rollback();
+				throw error;
+			}
 		},
 		use(plugin) {
-			const { hooks: pluginHooks, init, dispose, methods } = plugin(this);
+			const { hooks: pluginHooks, init, dispose, methods } = plugin;
 			if (pluginHooks) {
-				if (pluginHooks.onBeforePut) {
-					const callback = pluginHooks.onBeforePut;
-					listeners.beforePut.add(callback);
-					disposers.add(() => {
-						listeners.beforePut.delete(callback);
-					});
-				}
-				if (pluginHooks.onBeforePatch) {
-					const callback = pluginHooks.onBeforePatch;
-					listeners.beforePatch.add(callback);
-					disposers.add(() => {
-						listeners.beforePatch.delete(callback);
-					});
-				}
-				if (pluginHooks.onBeforeDelete) {
-					const callback = pluginHooks.onBeforeDelete;
-					listeners.beforeDel.add(callback);
-					disposers.add(() => {
-						listeners.beforeDel.delete(callback);
-					});
-				}
 				if (pluginHooks.onPut) {
 					const callback = pluginHooks.onPut;
 					listeners.put.add(callback);
@@ -383,7 +345,7 @@ const create$1 = () => {
 			return this;
 		},
 		async init() {
-			for (const fn of initializers) await fn();
+			for (const fn of initializers) await fn(this);
 			return this;
 		},
 		async dispose() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@byearlybird/starling",
-	"version": "0.3.0",
+	"version": "0.5.0",
 	"type": "module",
 	"license": "MIT",
 	"main": "./dist/index.js",