@verdant-web/common 1.14.0 → 1.15.0

package/src/oids.ts

@@ -437,11 +437,12 @@ export function getOidRoot(oid: ObjectIdentifier) {
 
 /**
  * Returns an inclusive range of OIDs that represent
- * a root object and all of its sub-objects.
+ * all of an OID's possible sub-objects.
  */
-export function getOidRange(oid: ObjectIdentifier) {
+export function getOidSubIdRange(oid: ObjectIdentifier) {
 	const root = getOidRoot(oid);
-	return [root, `${root}${RANDOM_SEPARATOR}\uffff`];
+	const lastSubId = createSubOid(root, () => '\uffff');
+	return [`${root}${RANDOM_SEPARATOR}`, lastSubId];
 }
 
 export function getRoots(oids: ObjectIdentifier[]) {
@@ -455,3 +456,38 @@ export function getRoots(oids: ObjectIdentifier[]) {
 export function areOidsRelated(oidA: ObjectIdentifier, oidB: ObjectIdentifier) {
 	return getOidRoot(oidA) === getOidRoot(oidB);
 }
+
+/**
+ * Recursively rewrites any OIDs in an object which are 'foreign' -
+ * i.e. relate to some other object/entity - to be local to the
+ * current object. This is deterministic, so it can be done
+ * on multiple clients independently with predictable results.
+ */
+export function fixForeignOids(obj: any) {
+	const oid = maybeGetOid(obj);
+	if (!oid) return;
+
+	if (Array.isArray(obj)) {
+		for (let i = 0; i < obj.length; i++) {
+			migrateForeignOid(oid, obj[i]);
+			fixForeignOids(obj[i]);
+		}
+	} else if (isObject(obj)) {
+		for (const key of Object.keys(obj)) {
+			migrateForeignOid(oid, obj[key]);
+			fixForeignOids(obj[key]);
+		}
+	}
+}
+
+function migrateForeignOid(parentOid: ObjectIdentifier, child: any) {
+	const childOid = maybeGetOid(child);
+	if (childOid && !areOidsRelated(parentOid, childOid)) {
+		const { subId, id } = decomposeOid(childOid);
+		// reuse existing subId. if child is a foreign root, use its id as subId
+		assignOid(
+			child,
+			createSubOid(parentOid, () => subId || id),
+		);
+	}
+}

package/src/schema/fields.ts

@@ -8,6 +8,24 @@ export function isNullable(field: StorageFieldSchema) {
 	return field.nullable;
 }
 
+export function hasDefault(field: StorageFieldSchema | undefined) {
+	if (!field) return false;
+	if (field.type === 'map') return true;
+	if (field.type === 'array') return true;
+	if (field.type === 'file') return false;
+	if (field.type === 'object') return true;
+	return field.default !== undefined;
+}
+
+export function isIndexed(field: StorageFieldSchema) {
+	if (field.type === 'map') return false;
+	if (field.type === 'object') return false;
+	if (field.type === 'array') return false;
+	if (field.type === 'file') return false;
+	if (field.type === 'any') return false;
+	return field.indexed;
+}
+
 export function addFieldDefaults(
 	collection: StorageCollectionSchema,
 	value: any,

package/src/schema/index.ts

@@ -1,8 +1,11 @@
+import { isIndexed } from './fields.js';
 import {
 	CollectionCompoundIndices,
 	StorageCollectionSchema,
+	StorageDirectSyntheticSchema,
 	StorageFieldsSchema,
 	StorageSchema,
+	StorageSyntheticIndexSchema,
 	StorageSyntheticIndices,
 } from './types.js';
 
@@ -10,15 +13,39 @@ export function collection<
 	Fields extends StorageFieldsSchema,
 	Synthetics extends StorageSyntheticIndices<Fields>,
 	Compounds extends CollectionCompoundIndices<Fields, Synthetics>,
->(input: StorageCollectionSchema<Fields, Synthetics, Compounds>) {
-	return input;
+>({
+	synthetics,
+	indexes,
+	...input
+}: StorageCollectionSchema<
+	Fields,
+	Synthetics,
+	Compounds
+>): StorageCollectionSchema<Fields, Synthetics, Compounds> {
+	// back compat - copy synthetics in with indexes
+	const finalIndexes = { ...synthetics, ...indexes };
+	// add all indexed fields into the synthetic indices (back compat)
+	for (const [key, field] of Object.entries(input.fields)) {
+		if (isIndexed(field)) {
+			finalIndexes[key] = {
+				field: key,
+			} as StorageDirectSyntheticSchema<Fields>;
+		}
+	}
+	return {
+		...input,
+		indexes: finalIndexes as Synthetics,
+	};
 }
 
 export function schema<
+	// Fields extends StorageFieldsSchema,
+	// Indexes extends StorageSyntheticIndices<Fields>,
+	// Compounds extends CollectionCompoundIndices<Fields, Indexes>,
 	Schema extends StorageSchema<{
 		[key: string]: StorageCollectionSchema<any, any, any>;
 	}>,
->(input: Schema) {
+>(input: Schema): StorageSchema {
 	return input;
 }
 

package/src/schema/types/collection.ts

@@ -1,13 +1,7 @@
 import { CollectionCompoundIndices } from './compounds.js';
+import { StorageFieldsSchema } from './fields.js';
 import {
-	NestedStorageFieldSchema,
-	StorageFieldSchema,
-	StorageFieldsSchema,
-	StorageIndexableFields,
-} from './fields.js';
-import { StorageDocument } from './shapes.js';
-import {
-	StorageSyntheticIndexSchema,
+	DirectIndexableFieldName,
 	StorageSyntheticIndices,
 } from './synthetics.js';
 
@@ -16,7 +10,8 @@ import {
  */
 export type StorageCollectionSchema<
 	Fields extends StorageFieldsSchema = StorageFieldsSchema,
-	Synthetics extends StorageSyntheticIndices<Fields> = StorageSyntheticIndices<Fields>,
+	Synthetics extends
+		StorageSyntheticIndices<Fields> = StorageSyntheticIndices<Fields>,
 	Compounds extends CollectionCompoundIndices<
 		Fields,
 		Synthetics
@@ -24,110 +19,17 @@ export type StorageCollectionSchema<
 > = {
 	name: string;
 	/**
-	 * Optionally provide a plural name. Useful for some code generation purposes.
+	 * Your primary key must be a string, number, or boolean field. It must also
+	 * not be rewritten.
 	 */
-	pluralName?: string;
+	primaryKey: DirectIndexableFieldName<Fields>;
 	fields: Fields;
-	synthetics?: Synthetics;
+	indexes?: Synthetics;
 	compounds?: Compounds;
-	primaryKey: StorageIndexablePropertyName<Fields, Synthetics>;
-};
-
-export type NamedSchema<
-	Schemas extends StorageCollectionSchema<any, any, any>,
-	Name extends string,
-> = Schemas extends { name: Name } ? Schemas : never;
-
-export type IndexedSchemaProperties<
-	Schema extends StorageCollectionSchema<any, any, any>,
-> = {
-	[K in keyof CollectionSchemaFields<Schema> as CollectionSchemaFields<Schema>[K] extends {
-		indexed: true;
-	}
-		? K
-		: never]: CollectionSchemaFields<Schema>[K];
-} & CollectionSchemaComputedIndexes<Schema> &
-	CollectionSchemaCompoundIndexes<Schema>;
-
-export type CollectionIndexName<
-	Collection extends StorageCollectionSchema<any, any, any>,
-> = Extract<keyof IndexedSchemaProperties<Collection>, string>;
-
-export type CollectionProperties<
-	Collection extends StorageCollectionSchema<any, any, any>,
-> = Collection['fields'] & Collection['synthetics'];
-
-export type CollectionPropertyName<
-	Collection extends StorageCollectionSchema<any, any, any>,
-> = Exclude<keyof CollectionProperties<Collection>, number | symbol>;
-
-export type CollectionEvents<
-	Collection extends StorageCollectionSchema<any, any, any>,
-> = {
-	put: (value: StorageDocument<Collection>) => void;
-	delete: (id: string) => void;
-	[key: `put:${string}`]: (value: StorageDocument<Collection>) => void;
-	[key: `delete:${string}`]: () => void;
+	/**
+	 * @deprecated - plural name is the key used to index this collection in the schema. this field is no longer used.
+	 */
+	pluralName?: string;
+	/** @deprecated - use "indexes" */
+	synthetics?: Synthetics;
 };
-
-export type SchemaForCollection<
-	Collection extends StorageCollectionSchema<any, any, any>,
-> = Collection;
-
-export type CollectionSchemaFields<
-	Schema extends StorageCollectionSchema<any, any, any>,
-> = Schema extends StorageCollectionSchema<infer F, any, any> ? F : never;
-export type CollectionSchemaComputedIndexes<
-	Schema extends StorageCollectionSchema<any, any, any>,
-> = Schema extends StorageCollectionSchema<any, infer S, any> ? S : never;
-export type CollectionSchemaCompoundIndexes<
-	Schema extends StorageCollectionSchema<any, any, any>,
-> = Schema extends StorageCollectionSchema<any, any, infer C> ? C : never;
-
-export type StorageIndexableProperties<
-	Schema extends StorageCollectionSchema<any, any, any>,
-> = {
-	[K in keyof CollectionSchemaFields<Schema>]: CollectionSchemaFields<Schema>[K] extends {
-		indexed: boolean;
-	}
-		? CollectionSchemaFields<Schema>[K]
-		: never;
-} & CollectionSchemaComputedIndexes<Schema>;
-
-export type StorageSchemaProperty<
-	Schema extends StorageCollectionSchema<any, any, any>,
-> = StorageSchemaProperties<Schema>[keyof StorageSchemaProperties<Schema>];
-
-export type StorageSchemaPropertyName<
-	Schema extends StorageCollectionSchema<any, any, any>,
-> = Extract<keyof StorageSchemaProperties<Schema>, string>;
-
-export type GetSchemaProperty<
-	Schema extends StorageCollectionSchema<any, any, any>,
-	Key extends StorageSchemaPropertyName<Schema>,
-> = StorageSchemaProperties<Schema>[Key];
-
-export type StoragePropertySchema<BaseFields extends StorageFieldsSchema> =
-	| StorageFieldSchema
-	| NestedStorageFieldSchema
-	| StorageSyntheticIndexSchema<BaseFields>;
-
-export type StoragePropertyName<
-	Fields extends StorageFieldsSchema,
-	Synthetics extends StorageSyntheticIndices<Fields>,
-> =
-	| Exclude<keyof Fields, number | symbol>
-	| Exclude<keyof Synthetics, number | symbol>;
-
-export type StorageIndexablePropertyName<
-	Fields extends StorageFieldsSchema,
-	Synthetics extends StorageSyntheticIndices<Fields>,
-> =
-	| Extract<keyof StorageIndexableFields<Fields>, string>
-	| Extract<keyof Synthetics, string>;
-
-export type StorageSchemaProperties<
-	Schema extends StorageCollectionSchema<any, any, any>,
-> = Schema extends StorageCollectionSchema<infer F, infer S, infer C>
-	? F & S & C
-	: never;

package/src/schema/types/compounds.ts

@@ -1,33 +1,44 @@
 import {
-	CollectionSchemaCompoundIndexes,
-	StorageCollectionSchema,
-	StoragePropertyName,
-} from './collection.js';
-import { StorageFieldsSchema, StorageObjectFieldSchema } from './fields.js';
-import { StorageSyntheticIndices } from './synthetics.js';
+	NestedStorageBooleanFieldSchema,
+	NestedStorageNumberFieldSchema,
+	NestedStorageStringFieldSchema,
+	StorageArrayFieldSchema,
+	StorageFieldsSchema,
+} from './fields.js';
+import {
+	DirectIndexableFieldName,
+	StorageSyntheticIndices,
+} from './synthetics.js';
 
-type OmitObjectFields<T extends StorageFieldsSchema> = {
-	[K in keyof T]: T[K] extends StorageObjectFieldSchema ? never : T[K];
+// arrays of primitives are eligible for compound indices
+type PrimitiveArrayFields<Fields extends StorageFieldsSchema> = {
+	[K in keyof Fields as Fields[K] extends StorageArrayFieldSchema
+		? Fields[K]['items'] extends
+				| NestedStorageStringFieldSchema
+				| NestedStorageNumberFieldSchema
+				| NestedStorageBooleanFieldSchema
+			? K
+			: never
+		: never]: Fields[K];
 };
+type PrimitiveArrayFieldName<Fields extends StorageFieldsSchema> = Extract<
+	keyof PrimitiveArrayFields<Fields>,
+	string
+>;
 
 export type CollectionCompoundIndex<
 	Fields extends StorageFieldsSchema,
 	Synthetics extends StorageSyntheticIndices<Fields>,
 > = {
 	// object fields cannot be compound index inputs
-	of: StoragePropertyName<OmitObjectFields<Fields>, Synthetics>[];
+	of: (
+		| DirectIndexableFieldName<Fields>
+		| PrimitiveArrayFieldName<Fields>
+		| Extract<keyof Synthetics, string>
+	)[];
 };
-type CompoundFieldNameTuple<Name extends string> =
-	| [Name, Name]
-	| [Name, Name, Name]
-	| [Name, Name, Name, Name]
-	| [Name, Name, Name, Name, Name];
 
 export type CollectionCompoundIndices<
 	Fields extends StorageFieldsSchema,
 	Synthetics extends StorageSyntheticIndices<Fields>,
 > = Record<string, CollectionCompoundIndex<Fields, Synthetics>>;
-
-export type CollectionCompoundIndexName<
-	Collection extends StorageCollectionSchema<any, any, any>,
-> = Exclude<keyof CollectionSchemaCompoundIndexes<Collection>, number | symbol>;

package/src/schema/types/fields.ts

@@ -1,11 +1,13 @@
 export type StorageStringFieldSchema = {
 	type: 'string';
+	/** @deprecated - add an index to indexes with this field name. */
 	indexed?: boolean;
 	nullable?: boolean;
 	default?: string | (() => string);
 };
 export type StorageNumberFieldSchema = {
 	type: 'number';
+	/** @deprecated - add an index to indexes with this field name. */
 	indexed?: boolean;
 	nullable?: boolean;
 	default?: number | (() => number);
@@ -14,6 +16,7 @@ export type StorageBooleanFieldSchema = {
 	type: 'boolean';
 	nullable?: boolean;
 	default?: boolean | (() => boolean);
+	/** @deprecated - add an index to indexes with this field name. */
 	indexed?: boolean;
 };
 export type StorageArrayFieldSchema = {
@@ -66,18 +69,25 @@ export type NestedStorageNumberFieldSchema = {
 	nullable?: boolean;
 	default?: number | (() => number);
 };
+export type NestedStorageBooleanFieldSchema = {
+	type: 'boolean';
+	nullable?: boolean;
+	default: boolean | (() => boolean);
+};
 
 export type NestedStorageFieldSchema =
 	| NestedStorageStringFieldSchema
 	| NestedStorageNumberFieldSchema
-	| StorageBooleanFieldSchema
+	| NestedStorageBooleanFieldSchema
 	| StorageArrayFieldSchema
 	| StorageObjectFieldSchema
 	| StorageAnyFieldSchema
 	| StorageMapFieldSchema<any>
 	| StorageFileFieldSchema;
 
-export type StorageFieldsSchema = Record<string, StorageFieldSchema>;
+export type StorageFieldsSchema = {
+	[key: string]: StorageFieldSchema;
+};
 
 export type NestedStorageFieldsSchema = Record<
 	string,

package/src/schema/types/shapes.ts

@@ -1,25 +1,24 @@
-import {
-	StorageCollectionSchema,
-	StoragePropertySchema,
-} from './collection.js';
+import { StorageCollectionSchema } from './collection.js';
 import {
 	NestedStorageFieldsSchema,
 	StorageArrayFieldSchema,
+	StorageFieldSchema,
 	StorageFieldsSchema,
 	StorageMapFieldSchema,
 	StorageObjectFieldSchema,
 } from './fields.js';
 
-type StoragePropertyIsNullable<T extends StoragePropertySchema<any>> =
-	T extends { nullable?: boolean }
-		? T['nullable'] extends boolean
-			? true
-			: false
-		: T['type'] extends 'any'
+type StoragePropertyIsNullable<T extends StorageFieldSchema> = T extends {
+	nullable?: boolean;
+}
+	? T['nullable'] extends boolean
 		? true
-		: false;
+		: false
+	: T['type'] extends 'any'
+	? true
+	: false;
 
-export type BaseShapeFromProperty<T extends StoragePropertySchema<any>> =
+export type BaseShapeFromProperty<T extends StorageFieldSchema> =
 	T['type'] extends 'string'
 		? string
 		: T['type'] extends 'number'
@@ -38,7 +37,7 @@ export type BaseShapeFromProperty<T extends StoragePropertySchema<any>> =
 		? File
 		: never;
 
-export type ShapeFromProperty<T extends StoragePropertySchema<any>> =
+export type ShapeFromProperty<T extends StorageFieldSchema> =
 	StoragePropertyIsNullable<T> extends true
 		? BaseShapeFromProperty<T> | null
 		: BaseShapeFromProperty<T>;
@@ -53,7 +52,7 @@ export type StorageDocument<
 	Collection extends StorageCollectionSchema<any, any, any>,
 > = ShapeFromFields<Collection['fields']>;
 
-type StoragePropertyIsOptional<T extends StoragePropertySchema<any>> =
+type StoragePropertyIsOptional<T extends StorageFieldSchema> =
 	StoragePropertyIsNullable<T> extends true
 		? true
 		: T extends { default?: any }

package/src/schema/types/synthetics.ts

@@ -1,4 +1,10 @@
-import { StorageFieldsSchema } from './fields.js';
+import {
+	StorageBooleanFieldSchema,
+	StorageFieldSchema,
+	StorageFieldsSchema,
+	StorageNumberFieldSchema,
+	StorageStringFieldSchema,
+} from './fields.js';
 import { ShapeFromFields } from './shapes.js';
 
 export type StorageStringSyntheticSchema<Fields extends StorageFieldsSchema> = {
@@ -32,6 +38,23 @@ export type StorageBooleanArraySyntheticSchema<
 	type: 'boolean[]';
 	compute: (value: ShapeFromFields<Fields>) => boolean[];
 };
+export type StorageDirectSyntheticSchema<Fields extends StorageFieldsSchema> = {
+	field: DirectIndexableFieldName<Fields>;
+};
+
+type DirectIndexableFields<Fields extends StorageFieldsSchema> = {
+	[K in keyof Fields as Fields[K] extends StorageStringFieldSchema
+		? K
+		: Fields[K] extends StorageNumberFieldSchema
+		? K
+		: Fields[K] extends StorageBooleanFieldSchema
+		? K
+		: never]: any;
+};
+export type DirectIndexableFieldName<Fields extends StorageFieldsSchema> =
+	keyof DirectIndexableFields<Fields> extends never
+		? string
+		: keyof DirectIndexableFields<Fields>;
 
 export type StorageSyntheticIndices<Fields extends StorageFieldsSchema> =
 	Record<string, StorageSyntheticIndexSchema<Fields>>;
@@ -42,4 +65,10 @@ export type StorageSyntheticIndexSchema<Fields extends StorageFieldsSchema> =
 	| StorageBooleanSyntheticSchema<Fields>
 	| StorageStringArraySyntheticSchema<Fields>
 	| StorageNumberArraySyntheticSchema<Fields>
-	| StorageBooleanArraySyntheticSchema<Fields>;
+	| StorageBooleanArraySyntheticSchema<Fields>
+	| StorageDirectSyntheticSchema<Fields>;
+
+export type IndexValueTag = Exclude<
+	StorageSyntheticIndexSchema<any>,
+	StorageDirectSyntheticSchema<any>
+>['type'];

package/src/schema/types.ts

@@ -7,15 +7,13 @@ export * from './types/filters.js';
 export * from './types/shapes.js';
 export * from './types/synthetics.js';
 
-export interface StorageInit<Schemas extends StorageCollectionSchema> {
-	collections: Record<string, Schemas>;
-}
-
 export type StorageSchema<
 	Collections extends {
 		[k: string]: StorageCollectionSchema;
-	} = any,
-> = { version: number; collections: Collections };
+	} = {
+		[k: string]: StorageCollectionSchema;
+	},
+> = { version: number; wip?: true; collections: Collections };
 
 export type SchemaCollectionName<Schema extends StorageSchema<any>> =
 	Schema extends StorageSchema<infer Cs>

package/src/utils.ts

@@ -1,5 +1,6 @@
 import { v4 } from 'uuid';
 import { assignOid, maybeGetOid } from './oids.js';
+import hash from 'object-hash';
 
 export function take<T extends object, Keys extends keyof T>(
 	obj: T,
@@ -86,7 +87,8 @@ export function cloneDeep<T>(obj: T, copyOids = true): T {
 
 // TODO: better hash
 export function hashObject(obj: any) {
-	return stableStringify(obj);
+	// hash the object into a unique string
+	return hash(obj);
 }
 
 export function isObject(obj: any) {