@harperfast/harper-pro 5.0.30 → 5.1.0-beta.2

package/core/resources/ResourceInterface.ts

@@ -19,8 +19,8 @@ export interface ResourceInterface<Record extends object = any>
 
 	allowCreate(user: User, record: Promise<Record & RecordObject>, context: Context): boolean | Promise<boolean>;
 	create?(
-		newRecord: Partial<Record & RecordObject>,
-		target: RequestTargetOrId
+		target: RequestTargetOrId,
+		newRecord: Partial<Record & RecordObject>
 	): void | (Record & Partial<RecordObject>) | Promise<Record & Partial<RecordObject>>;
 	post?(
 		target: RequestTargetOrId,
@@ -32,10 +32,6 @@ export interface ResourceInterface<Record extends object = any>
 		record: Record & RecordObject,
 		target?: RequestTargetOrId
 	): void | (Record & Partial<RecordObject>) | Promise<void | (Record & Partial<RecordObject>)>;
-	patch?(
-		record: Partial<Record & RecordObject>,
-		target: RequestTargetOrId
-	): void | (Record & Partial<RecordObject>) | Promise<void | (Record & Partial<RecordObject>)>;
 	update?(updates: Record & RecordObject, fullUpdate: true): ResourceInterface<Record & Partial<RecordObject>>;
 	update?(
 		updates: Partial<Record & RecordObject>,
@@ -101,6 +97,20 @@ export interface Context {
 	resourceCache?: Map<Id, any>;
 	_freezeRecords?: boolean; // until v5, we conditionally freeze records for back-compat
 	timestamp?: number;
+	includeExpensiveRecordCountEstimates?: boolean;
+	/**
+	 * Matched route path of the calling Resource, populated by the HTTP/WS entry points
+	 * before they hand the request into `transaction()`. Populated on the Request that
+	 * becomes the ALS-bound Context for that path; absent for ops-API, internal jobs,
+	 * and replication-driven contexts.
+	 */
+	handlerPath?: string;
+	/**
+	 * Abort signal carried through ALS so generator bodies can forward cancellation to
+	 * external work (e.g. `scope.models.generateStream({ signal })`). Populated on the
+	 * Request that becomes the ALS-bound Context for HTTP/WS paths via #513.
+	 */
+	signal?: AbortSignal;
 }
 
 export interface SourceContext<TRequestContext = Context, Record extends object = any> {
@@ -128,19 +138,27 @@ export interface SourceContext<TRequestContext = Context, Record extends object
 
 export type Operator = 'and' | 'or';
 
-export type Comparator =
-	| 'between'
-	| 'contains'
-	| 'ends_with'
-	| 'eq'
-	| 'equals'
-	| 'greater_than'
-	| 'greater_than_equal'
-	| 'less_than'
-	| 'less_than_equal'
-	| 'ne'
-	| 'not_equal'
-	| 'starts_with';
+export const COMPARATORS = [
+	'between',
+	'contains',
+	'ends_with',
+	'eq',
+	'equals',
+	'gt',
+	'ge',
+	'lt',
+	'le',
+	'greater_than',
+	'greater_than_equal',
+	'in',
+	'less_than',
+	'less_than_equal',
+	'ne',
+	'not_equal',
+	'starts_with',
+] as const;
+
+export type Comparator = (typeof COMPARATORS)[number];
 
 export type DirectCondition<Record extends object = any> = TypedDirectCondition<Record, keyof Record>;
 
@@ -149,8 +167,13 @@ interface TypedDirectCondition<Record extends object, Property extends keyof Rec
 	search_attribute?: keyof Record | Array<keyof Record> | string | string[];
 	comparator?: Comparator;
 	search_type?: Comparator;
-	value?: Record[Property];
-	search_value?: Record[Property];
+	value?: Record[Property] | Record[Property][];
+	search_value?: Record[Property] | Record[Property][];
+	/**
+	 * If true, the condition is negated. Phase 1: filter-only — forces a
+	 * full scan unless paired with another indexed condition.
+	 */
+	negated?: boolean;
 }
 
 interface ConditionGroup<Record extends object = any> {

package/core/resources/Resources.ts

@@ -1,12 +1,10 @@
-import { Resource } from './Resource.ts';
 import { transaction } from './transaction.ts';
-import { ErrorResource } from './ErrorResource.ts';
-import logger from '../utility/logging/harper_logger.js';
-import { ServerError } from '../utility/errors/hdbError.js';
+import logger from '../utility/logging/harper_logger.ts';
+import { ServerError } from '../utility/errors/hdbError.ts';
 import { server } from '../server/Server.ts';
 
 interface ResourceEntry {
-	Resource: typeof Resource;
+	Resource: any;
 	path: string;
 	exportTypes: any;
 	hasSubPaths: boolean;
@@ -18,11 +16,12 @@ interface ResourceEntry {
  */
 export class Resources extends Map<string, ResourceEntry> {
 	isWorker = true;
-	loginPath?: (request) => string;
+	loginPath?: (request: any) => string;
 
 	allTypes: Map<any, any> = new Map();
 
-	set(path, resource, exportTypes?: { [key: string]: boolean }, force?: boolean): void {
+	// @ts-expect-error override with different signature
+	set(path: string, resource: any, exportTypes?: { [key: string]: boolean }, force?: boolean): void {
 		if (!resource) throw new Error('Must provide a resource');
 		if (path.startsWith('/')) path = path.replace(/^\/+/, '');
 		const entry = {
@@ -45,6 +44,7 @@ export class Resources extends Map<string, ResourceEntry> {
 			// don't provide anything more descriptive.
 			const error = new ServerError(`Conflicting paths for ${path}`);
 			logger.error(error);
+			const { ErrorResource } = require('./ErrorResource');
 			entry.Resource = new ErrorResource(error);
 		}
 		super.set(path, entry);
@@ -131,7 +131,7 @@ export class Resources extends Map<string, ResourceEntry> {
 		const entry = this.getMatch(path);
 		if (entry) {
 			path = entry.relativeURL;
-			return entry.Resource.getResource(this.pathToId(path, entry.Resource), resourceInfo);
+			return entry.Resource.getResource((this as any).pathToId(path, entry.Resource), resourceInfo);
 		}
 	}
 	call(path: string, request, callback: Function) {

package/core/resources/RocksIndexStore.ts

@@ -46,6 +46,7 @@ export class RocksIndexStore extends RocksDatabase {
 	 * @param primaryKey
 	 * @param txnId
 	 */
+	// @ts-ignore
 	put(indexedValue: any, primaryKey: Id, options: StorePutOptions) {
 		return super.putSync([indexedValue, primaryKey], null, options);
 	}
@@ -54,10 +55,12 @@ export class RocksIndexStore extends RocksDatabase {
 		return super.putSync([indexedValue, primaryKey], null, options);
 	}
 
+	// @ts-ignore
 	remove(indexedValue: any, primaryKey: Id, options?: StoreRemoveOptions) {
 		return super.removeSync([indexedValue, primaryKey], options);
 	}
 
+	// @ts-ignore
 	removeSync(indexedValue: any, primaryKey: Id, options?: StoreRemoveOptions) {
 		super.removeSync([indexedValue, primaryKey], options);
 	}

package/core/resources/RocksTransactionLogStore.ts

@@ -2,6 +2,7 @@ import { TransactionLog, RocksDatabase, shutdown, type TransactionEntry } from '
 import { ExtendedIterable } from '@harperfast/extended-iterable';
 import { getIdOfRemoteNode } from './nodeIdMapping.ts';
 import { Decoder, readAuditEntry, ENTRY_DATAVIEW, AuditRecord, createAuditEntry } from './auditStore.ts';
+import { endIteratorOnCorruptFrame } from './replayLogsGuards.ts';
 import { isMainThread } from 'node:worker_threads';
 import { EventEmitter } from 'node:events';
 import { asBinary } from 'lmdb';
@@ -21,6 +22,13 @@ type TransactionLogIterator = Iterator<TransactionEntry | number> & {
 	removeLog(logName: string);
 };
 
+// Logs (once per log) when a corrupt frame ends a query iterator early; see
+// endIteratorOnCorruptFrame in replayLogsGuards.ts for why this is end-of-log, not a crash.
+function warnCorruptFrame(logName: string) {
+	return (error: RangeError) =>
+		harperLogger.warn(`Stopping transaction log "${logName}" at a corrupt entry during replay`, error);
+}
+
 /**
  * Represents a transaction log store backed by RocksDB.
  * This class provides methods that conform to a standard store interface
@@ -125,7 +133,8 @@ export class RocksTransactionLogStore extends EventEmitter {
 		throw new Error('Not implemented');
 	}
 	addLogToMaps(logName: string, log: TransactionLog) {
-		const nodeId = (getIdOfRemoteNode(logName, this) ?? 0) as number;
+		// 'local' is always the local node's log, which maps to nodeId 0
+		const nodeId = (logName === 'local' ? 0 : getIdOfRemoteNode(logName, this)) as number;
 		if (this.nodeLogs) {
 			this.nodeLogs![nodeId] ??= log;
 		}
@@ -189,7 +198,7 @@ export class RocksTransactionLogStore extends EventEmitter {
 					log = this.rootStore.useLog(options.log);
 				}
 			}
-			const queryIterator = log.query(options);
+			const queryIterator = endIteratorOnCorruptFrame(log.query(options), warnCorruptFrame(log.name));
 			iterable.iterate = () => queryIterator;
 		} else {
 			const onlyKeys = options.onlyKeys;
@@ -240,7 +249,7 @@ export class RocksTransactionLogStore extends EventEmitter {
 								// condition of potentially missing an initial update
 								queryOptions = { ...options, start: options.start ?? 0 };
 							}
-							iterators.push(log.query(queryOptions));
+							iterators.push(endIteratorOnCorruptFrame(log.query(queryOptions), warnCorruptFrame(log.name)));
 						}
 					}
 					latestUpdates = this.updates;
@@ -409,7 +418,7 @@ export class RocksTransactionLogStore extends EventEmitter {
 	getUserSharedBuffer(key: string | symbol, defaultBuffer: ArrayBuffer, options?: { callback?: () => void }) {
 		return this.rootStore.getUserSharedBuffer(key, defaultBuffer, options);
 	}
-	on(eventName: string, listener: any) {
+	on(eventName: string, listener: any): any {
 		if (eventName === 'aftercommit') {
 			return super.on('aftercommit', listener);
 		} else {