@harperfast/harper 5.2.13 → 5.3.0-beta.1

package/resources/defineTable.ts

@@ -27,6 +27,8 @@
 
 import { table, type Table } from './databases.ts';
 import { attributeToFragment } from './jsonSchemaTypes.ts';
+import type { RecordLockOptions } from './recordLock.ts';
+import type { WritableRecord } from './ResourceInterface.ts';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Field model — phantom-typed Field. Flags are set via GETTER PROPERTIES (no call):
@@ -235,6 +237,7 @@ interface TypedVerbs<S extends Shape> {
 	post(record: InsertOf<S>, context?: any): MaybePromise<unknown>;
 	patch(id: IdOf<S>, changes: PatchOf<S>, context?: any): MaybePromise<unknown>;
 	update(id: IdOf<S>, updates?: PatchOf<S>, context?: any): MaybePromise<InstanceOf<S>>;
+	lock(id: IdOf<S>, options?: RecordLockOptions, context?: any): Promise<WritableRecord<InstanceOf<S>>>;
 	delete(id: IdOf<S>, context?: any): MaybePromise<unknown>;
 	search(query?: any, context?: any): AsyncIterable<ReadVariant<S>>;
 	query(query?: any, context?: any): AsyncIterable<ReadVariant<S>>;
@@ -248,7 +251,7 @@ interface TypedVerbs<S extends Shape> {
  */
 export type TableHandle<S extends Shape = Shape> = Omit<
 	Table,
-	'get' | 'put' | 'post' | 'patch' | 'update' | 'delete' | 'search' | 'query'
+	'get' | 'put' | 'post' | 'patch' | 'update' | 'lock' | 'delete' | 'search' | 'query'
 > &
 	TypedVerbs<S> & {
 		// phantom projection carriers — discovery surface, zero runtime cost
@@ -400,8 +403,21 @@ function compileTypeDef(name: string, shape: Shape, options: DefineTableOptions)
  * index changes) through the same evolution path GraphQL reloads take.
  */
 export function defineTable<S extends Shape>(name: string, shape: S, options: DefineTableOptions = {}): TableHandle<S> {
+	return defineTableUsing(table, name, shape, options);
+}
+
+/**
+ * `defineTable` through a specific table factory: the one a branched application's scope hands out
+ * (`scopedTableFactory`), so the table lands in its branch. Internal -- the public entry is `defineTable`.
+ */
+export function defineTableUsing<S extends Shape>(
+	tableFactory: typeof table,
+	name: string,
+	shape: S,
+	options: DefineTableOptions = {}
+): TableHandle<S> {
 	const typeDef = compileTypeDef(name, shape, options);
-	const tableClass = table(typeDef);
+	const tableClass = tableFactory(typeDef);
 	typeDef.tableClass = tableClass;
 	return tableClass as TableHandle<S>;
 }

package/resources/derivedIndexRegistry.ts

@@ -0,0 +1,56 @@
+const registrations = new WeakMap<object, Map<number, number>>();
+const admissions = new WeakMap<object, Map<number, Array<() => string | undefined>>>();
+
+/** `admission` returns a reason while writes to these tables must be rejected. */
+export function registerDerivedIndexTables(
+	auditStore: object,
+	tableIds: Iterable<number>,
+	admission?: () => string | undefined
+): () => void {
+	const registeredTableIds = new Set(tableIds);
+	let counts = registrations.get(auditStore);
+	if (!counts) registrations.set(auditStore, (counts = new Map()));
+	for (const tableId of registeredTableIds) counts.set(tableId, (counts.get(tableId) ?? 0) + 1);
+	let checks: Map<number, Array<() => string | undefined>> | undefined;
+	if (admission) {
+		checks = admissions.get(auditStore);
+		if (!checks) admissions.set(auditStore, (checks = new Map()));
+		for (const tableId of registeredTableIds) {
+			let byTable = checks.get(tableId);
+			if (!byTable) checks.set(tableId, (byTable = []));
+			byTable.push(admission);
+		}
+	}
+	let registered = true;
+	return () => {
+		if (!registered) return;
+		registered = false;
+		for (const tableId of registeredTableIds) {
+			const count = counts!.get(tableId);
+			if (count === 1) counts!.delete(tableId);
+			else if (count) counts!.set(tableId, count - 1);
+			if (admission && checks) {
+				const byTable = checks.get(tableId);
+				const index = byTable?.indexOf(admission) ?? -1;
+				if (byTable && index >= 0) byTable.splice(index, 1);
+				if (byTable?.length === 0) checks.delete(tableId);
+			}
+		}
+		if (counts!.size === 0) registrations.delete(auditStore);
+		if (checks?.size === 0) admissions.delete(auditStore);
+	};
+}
+
+export function hasDerivedIndexRegistration(auditStore: object, tableId: number): boolean {
+	return registrations.get(auditStore)?.has(tableId) ?? false;
+}
+
+/** The reason a write to this table must currently be rejected, or undefined when writes are admitted. */
+export function derivedIndexWriteRejection(auditStore: object, tableId: number): string | undefined {
+	const byTable = admissions.get(auditStore)?.get(tableId);
+	if (!byTable) return;
+	for (let i = 0; i < byTable.length; i++) {
+		const reason = byTable[i]();
+		if (reason) return reason;
+	}
+}