@verdant-web/store 3.4.0-next.0 → 3.5.0

package/dist/esm/types.d.ts

@@ -0,0 +1,12 @@
+import { Operation } from '@verdant-web/common';
+export type LogFunction = (...args: any[]) => void;
+/**
+ * Operations moving through the client system are
+ * tagged with whether or not they are stored in
+ * the database (confirmed) or only in memory,
+ * which might mean they are lost if the client
+ * crashes.
+ */
+export interface TaggedOperation extends Operation {
+    confirmed?: boolean;
+}

package/dist/esm/utils/Disposable.d.ts

@@ -0,0 +1,6 @@
+export declare class Disposable {
+    private _disposes;
+    protected disposed: boolean;
+    dispose: () => void;
+    protected addDispose: (dispose: () => void) => void;
+}

package/dist/esm/utils/Resolvable.d.ts

@@ -0,0 +1,8 @@
+export declare class Resolvable<T> {
+    readonly promise: Promise<T>;
+    private _resolve;
+    private _reject;
+    constructor();
+    resolve(value: T): void;
+    reject(reason?: any): void;
+}

package/dist/esm/vanilla.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verdant-web/store",
-  "version": "3.4.0-next.0",
+  "version": "3.5.0",
   "access": "public",
   "type": "module",
   "exports": {
@@ -27,7 +27,7 @@
     "jwt-decode": "^3.1.2",
     "kysely": "^0.27.3",
     "weak-event": "^2.0.5",
-    "@verdant-web/common": "2.3.0-next.0"
+    "@verdant-web/common": "2.3.0"
   },
   "devDependencies": {
     "@types/node": "20.10.5",
@@ -37,7 +37,7 @@
     "open-cli": "^7.2.0",
     "puppeteer": "^21.5.1",
     "typescript": "^5.4.2",
-    "vitest": "^1.1.0"
+    "vitest": "^1.4.0"
   },
   "scripts": {
     "test": "vitest",

package/src/__tests__/documents.test.ts

@@ -1,5 +1,4 @@
 import { assert } from '@verdant-web/common';
-import cuid from 'cuid';
 import { describe, it, expect, vi, MockedFunction, vitest } from 'vitest';
 import { createTestStorage } from './fixtures/testStorage.js';
 import { EntityFile } from '../index.js';
@@ -505,7 +504,9 @@ describe('storage documents', () => {
 
 		expect(() => {
 			item1.set('id', 'foo');
-		}).toThrowErrorMatchingInlineSnapshot(`[Error: Cannot set readonly key id]`);
+		}).toThrowErrorMatchingInlineSnapshot(
+			`[Error: Cannot set readonly key id]`,
+		);
 	});
 
 	it('should properly handle pushing to a list of files', async () => {
@@ -559,4 +560,36 @@ describe('storage documents', () => {
 		expect(fileList.get(1)).toBe(file3Ref);
 		expect(fileList.get(2)).toBe(file1Ref);
 	});
+
+	it('should return nullish for missing map items', async () => {
+		const storage = await createTestStorage();
+		const weird = await storage.weirds.put({});
+
+		const map = weird.get('map');
+		expect(map.get('foo')).toBeUndefined();
+		const objectMap = weird.get('objectMap');
+		expect(objectMap.get('foo')).toBeUndefined();
+		const arrayMap = weird.get('arrayMap');
+		expect(arrayMap.get('foo')).toBeUndefined();
+	});
+
+	it('should allow getOrSet for nullable fields', async () => {
+		const storage = await createTestStorage();
+		const weird = await storage.weirds.put({});
+
+		const map = weird.get('map');
+		const foo = map.getOrSet('foo', 'bar');
+		expect(foo).toBe('bar');
+		expect(map.get('foo')).toBe('bar');
+
+		const objectMap = weird.get('objectMap');
+		const fooObject = objectMap.getOrSet('foo', { content: 'bar' });
+		expect(fooObject.get('content')).toBe('bar');
+		expect(objectMap.get('foo').get('content')).toBe('bar');
+
+		const arrayMap = weird.get('arrayMap');
+		const fooArray = arrayMap.getOrSet('foo', ['bar']);
+		expect(fooArray.get(0)).toEqual('bar');
+		expect(arrayMap.get('foo').get(0)).toEqual('bar');
+	});
 });

package/src/__tests__/fixtures/testStorage.ts

@@ -70,6 +70,11 @@ export const weirdCollection = schema.collection({
 				},
 			}),
 		}),
+		arrayMap: schema.fields.map({
+			values: schema.fields.array({
+				items: schema.fields.string(),
+			}),
+		}),
 	},
 });
 

package/src/entities/Entity.ts

@@ -549,21 +549,23 @@ export class Entity<
 			);
 		}
 		const child = view[key as any];
-		const schema = getChildFieldSchema(this.schema, key);
-		if (!schema) {
+		const fieldSchema = getChildFieldSchema(this.schema, key);
+		if (!fieldSchema) {
 			throw new Error(
 				`No schema for key ${String(key)} in ${JSON.stringify(this.schema)}`,
 			);
 		}
 		if (isRef(child)) {
 			if (isFileRef(child)) {
-				if (schema.type !== 'file') {
+				if (fieldSchema.type !== 'file') {
 					throw new Error(
-						`Expected file schema for key ${String(key)}, got ${schema.type}`,
+						`Expected file schema for key ${String(key)}, got ${
+							fieldSchema.type
+						}`,
 					);
 				}
 				const file = this.files.get(child.id, {
-					downloadRemote: !!schema.downloadRemote,
+					downloadRemote: !!fieldSchema.downloadRemote,
 				});
 
 				// FIXME: this seems bad and inconsistent
@@ -576,20 +578,25 @@ export class Entity<
 				return this.getChild(key, child.id) as KeyValue[Key];
 			}
 		} else {
+			// if this is a Map type, a missing child is
+			// just an empty spot
+			if (this.schema.type === 'map' && child === undefined) {
+				return undefined as KeyValue[Key];
+			}
 			// prune invalid primitive fields
 			if (
 				validateEntityField({
-					field: schema,
+					field: fieldSchema,
 					value: child,
 					fieldPath: [...this.fieldPath, key],
 					depth: 1,
 					requireDefaults: true,
 				})
 			) {
-				if (hasDefault(schema)) {
-					return getDefault(schema);
+				if (hasDefault(fieldSchema)) {
+					return getDefault(fieldSchema);
 				}
-				if (isNullable(schema)) {
+				if (isNullable(fieldSchema)) {
 					return null as any;
 				}
 				return undefined as any;
@@ -598,6 +605,30 @@ export class Entity<
 		}
 	};
 
+	/**
+	 * Gets a value on this entity. If the value is not
+	 * present, it will be set to the provided default
+	 * and returned synchronously. This method only sets
+	 * a new value once when a field is empty; subsequent
+	 * calls will retrieve the created value until it is
+	 * deleted.
+	 *
+	 * Note that this should only be called for nullable
+	 * fields. If the field is not nullable, the existing
+	 * value or the default value will always be returned,
+	 * and the default will not be set.
+	 */
+	getOrSet = <Key extends keyof Init & keyof KeyValue>(
+		key: Key,
+		init: Init[Key],
+	): KeyValue[Key] => {
+		assertNotSymbol(key);
+		const existing = this.get(key);
+		if (existing) return existing;
+		this.set(key as any, init);
+		return this.get(key);
+	};
+
 	private processInputValue = (value: any, key: any) => {
 		if (this.readonlyKeys.includes(key as string)) {
 			throw new Error(`Cannot set readonly key ${key.toString()}`);