@harperfast/harper-pro 5.0.6 → 5.0.8

package/core/resources/RecordEncoder.ts

@@ -470,6 +470,7 @@ export function handleLocalTimeForGets(store, rootStore) {
 			};
 			Txn.prototype.done = function () {
 				done.call(this);
+				this.openTimer = 0; // reset so idle pool time doesn't accumulate toward the stale-open threshold
 				if (this.isDone) {
 					for (let i = 0; i < trackedTxns.length; i++) {
 						const txn = trackedTxns[i].deref();
@@ -498,7 +499,14 @@ setInterval(() => {
 							'Read transaction detected that has been open too long (over 15 minutes), ending transaction',
 							txn
 						);
-						txn.done();
+						trackedTxns.splice(i--, 1);
+						txn.timerTracked = false;
+						txn.openTimer = 0;
+						try {
+							txn.done();
+						} catch (error) {
+							harperLogger.warn('Unexpected error force-closing stale LMDB read transaction', error);
+						}
 					} else
 						harperLogger.error(
 							'Read transaction detected that has been open too long (over one minute), make sure read transactions are quickly closed',

package/core/resources/Table.ts

@@ -91,7 +91,6 @@ const NULL_WITH_TIMESTAMP = new Uint8Array(9);
 NULL_WITH_TIMESTAMP[8] = 0xc0; // null
 const UNCACHEABLE_TIMESTAMP = Infinity; // we use this when dynamic content is accessed that we can't safely cache, and this prevents earlier timestamps from change the "last" modification
 const RECORD_PRUNING_INTERVAL = 60000; // one minute
-const CACHEABLE_STATUS_CODES = new Set([200, 203, 204, 206, 300, 301, 308, 404, 405, 410, 414, 501]);
 envMngr.initSync();
 const LMDB_PREFETCH_WRITES = envMngr.get(CONFIG_PARAMS.STORAGE_PREFETCHWRITES);
 const LOCK_TIMEOUT = 10000;
@@ -364,6 +363,10 @@ export function makeTable(options) {
 						// we listen for events by iterating through the async iterator provided by the subscription
 						for await (const event of subscription) {
 							try {
+								if (!event || typeof event !== 'object') {
+									logger.error?.('Bad subscription event', event);
+									continue;
+								}
 								const firstWrite = event.type === 'transaction' ? event.writes[0] : event;
 								if (!firstWrite) {
 									logger.error?.('Bad subscription event', event);
@@ -1426,7 +1429,8 @@ export function makeTable(options) {
 		 */
 		static evict(id, existingRecord, existingVersion) {
 			let entry;
-			let transaction = txnForContext({ transaction: new DatabaseTransaction() }).getReadTxn();
+			const lmdbTransaction = txnForContext({ transaction: new DatabaseTransaction() });
+			let transaction = lmdbTransaction.getReadTxn();
 			let options = { transaction };
 			try {
 				if (hasSourceGet || audit) {
@@ -1453,7 +1457,13 @@ export function makeTable(options) {
 					return removeEntry(primaryStore, entry ?? primaryStore.getEntry(id), options);
 				}
 			} finally {
-				return transaction.commit();
+				if (primaryStore.ifVersion) {
+					// LMDB: committing the wrapper calls doneReadTxn(), removing it from trackedTxns
+					return lmdbTransaction.commit();
+				}
+				// RocksDB: eviction writes went directly into the raw transaction via options;
+				// commit it directly, as DatabaseTransaction.commit() would abort it (no tracked writes)
+				return transaction?.commit();
 			}
 		}
 		/**
@@ -4039,14 +4049,15 @@ export function makeTable(options) {
 							if (typeof updatedRecord !== 'object') throw new Error('Only objects can be cached and stored in tables');
 							if (updatedRecord.status > 0 && updatedRecord.headers) {
 								// if the source has a status code and headers, treat it as a response
-								const status = updatedRecord.status;
-								if (status === 304) {
-									// revalidation of our current cached record
-									updatedRecord = existingRecord;
-									version = existingVersion;
-								} else if (!CACHEABLE_STATUS_CODES.has(status)) {
-									// non-cacheable status - propagate to client without caching
-									throw new ServerError(updatedRecord.body || 'Error from source', status);
+								if (updatedRecord.status >= 300) {
+									if (updatedRecord.status === 304) {
+										// revalidation of our current cached record
+										updatedRecord = existingRecord;
+										version = existingVersion;
+									} else {
+										// if the source has an error status, we need to throw an error
+										throw new ServerError(updatedRecord.body || 'Error from source', updatedRecord.status);
+									} // there are definitely more status codes to handle
 								} else {
 									let headers: any;
 									const sourceHeaders = updatedRecord.headers;
@@ -4074,11 +4085,16 @@ export function makeTable(options) {
 									if (data !== undefined) {
 										// we have structured data that we have parsed
 										delete headers['content-type']; // don't store the content type if we have already parsed it
-										updatedRecord = { headers, data };
+										updatedRecord = {
+											headers,
+											data,
+										};
 									} else {
-										updatedRecord = { headers, body: createBlob(updatedRecord.body) };
+										updatedRecord = {
+											headers,
+											body: createBlob(updatedRecord.body),
+										};
 									}
-									if (status !== 200) updatedRecord.status = status;
 								}
 							}
 							if (typeof updatedRecord.toJSON === 'function') updatedRecord = updatedRecord.toJSON();

package/core/resources/databases.ts

@@ -184,6 +184,7 @@ export function getDatabases(): Databases {
 		getConfigPath(CONFIG_PARAMS.STORAGE_PATH) ||
 		(databasePath && (existsSync(databasePath) ? databasePath : join(getHdbBasePath(), LEGACY_DATABASES_DIR_NAME)));
 	if (!databasePath) return;
+
 	if (existsSync(databasePath)) {
 		// First load all the databases from our main database folder
 		// TODO: Load any databases defined with explicit storage paths from the config

package/core/resources/graphql.ts

@@ -4,6 +4,7 @@ import { table } from './databases.ts';
 import { getWorkerIndex } from '../server/threads/manageThreads.js';
 import { Resources } from './Resources.ts';
 import type { NamedTypeNode, StringValueNode } from 'graphql';
+import { once } from 'node:events';
 
 const PRIMITIVE_TYPES = ['ID', 'Int', 'Float', 'Long', 'String', 'Boolean', 'Date', 'Bytes', 'Any', 'BigInt', 'Blob'];
 
@@ -36,184 +37,193 @@ server.knownGraphQLDirectives.push(
  * @param resources
  */
 export function handleApplication(scope: import('../components/Scope.ts').Scope) {
-	scope.handleEntry(async (entry) => {
+	const entryHandler = scope.handleEntry(async (entry) => {
 		if (entry.eventType === 'unlink') return;
+		if (entry.entryType === 'directory') {
+			scope.logger.warn?.('graphqlSchema currently does not handle directories. Specify file patterns only.');
+			return;
+		}
+
 		await processGraphQLSchema(entry.contents, entry.urlPath, entry.absolutePath, scope.resources);
 	});
+	return once(entryHandler, 'initialLoadComplete');
 }
 
-async function processGraphQLSchema(gqlContent, urlPath, filePath, resources) {
-	// lazy load the graphql package so we don't load it for users that don't use graphql
-	const { parse, Source, Kind } = await import('graphql');
-	const ast = parse(new Source(gqlContent.toString(), filePath));
-	const types = new Map();
-	const tables = [];
-	// we begin by iterating through the definitions in the AST to get the types and convert them
-	// to a friendly format for table attributes
-	for (const definition of ast.definitions) {
-		switch (definition.kind) {
-			case Kind.OBJECT_TYPE_DEFINITION:
-				const typeName = definition.name.value;
-				// use type name as the default table
-				const properties = [];
-				const typeDef = { table: null, database: null, properties };
-				types.set(typeName, typeDef);
-				resources.allTypes.set(typeName, typeDef);
-				for (const directive of definition.directives) {
-					const directiveName = directive.name.value;
-					if (directiveName === 'table') {
-						for (const arg of directive.arguments) {
-							typeDef[arg.name.value] = (arg.value as StringValueNode).value;
+	async function handleFile(gqlContent, urlPath, filePath, resources) {
+		// lazy load the graphql package so we don't load it for users that don't use graphql
+		const { parse, Source, Kind } = await import('graphql');
+		const ast = parse(new Source(gqlContent.toString(), filePath));
+		const types = new Map();
+		const tables = [];
+		// we begin by iterating through the definitions in the AST to get the types and convert them
+		// to a friendly format for table attributes
+		for (const definition of ast.definitions) {
+			switch (definition.kind) {
+				case Kind.OBJECT_TYPE_DEFINITION:
+					const typeName = definition.name.value;
+					// use type name as the default table
+					const properties = [];
+					const typeDef = { table: null, database: null, properties };
+					types.set(typeName, typeDef);
+					resources.allTypes.set(typeName, typeDef);
+					for (const directive of definition.directives) {
+						const directiveName = directive.name.value;
+						if (directiveName === 'table') {
+							for (const arg of directive.arguments) {
+								typeDef[arg.name.value] = (arg.value as StringValueNode).value;
+							}
+							if (typeDef.schema) typeDef.database = typeDef.schema;
+							if (!typeDef.table) typeDef.table = typeName;
+							if (typeDef.audit) typeDef.audit = typeDef.audit !== 'false';
+							typeDef.attributes = typeDef.properties;
+							tables.push(typeDef);
 						}
-						if (typeDef.schema) typeDef.database = typeDef.schema;
-						if (!typeDef.table) typeDef.table = typeName;
-						if (typeDef.audit) typeDef.audit = typeDef.audit !== 'false';
-						typeDef.attributes = typeDef.properties;
-						tables.push(typeDef);
-					}
-					if (directive.name.value === 'sealed') typeDef.sealed = true;
-					if (directive.name.value === 'splitSegments') typeDef.splitSegments = true;
-					if (directive.name.value === 'replicate') typeDef.replicate = true;
-					if (directive.name.value === 'export') {
-						typeDef.export = true;
-						for (const arg of directive.arguments) {
-							if (typeof typeDef.export !== 'object') typeDef.export = {};
-							typeDef.export[arg.name.value] = (arg.value as StringValueNode).value;
+						if (directive.name.value === 'sealed') typeDef.sealed = true;
+						if (directive.name.value === 'splitSegments') typeDef.splitSegments = true;
+						if (directive.name.value === 'replicate') typeDef.replicate = true;
+						if (directive.name.value === 'export') {
+							typeDef.export = true;
+							for (const arg of directive.arguments) {
+								if (typeof typeDef.export !== 'object') typeDef.export = {};
+								typeDef.export[arg.name.value] = (arg.value as StringValueNode).value;
+							}
 						}
 					}
-				}
-				let hasPrimaryKey = false;
-				function getProperty(type) {
-					if (type.kind === 'NonNullType') {
-						const property = getProperty(type.type);
-						property.nullable = false;
+					let hasPrimaryKey = false;
+					function getProperty(type) {
+						if (type.kind === 'NonNullType') {
+							const property = getProperty(type.type);
+							property.nullable = false;
+							return property;
+						}
+						if (type.kind === 'ListType') {
+							return {
+								type: 'array',
+								elements: getProperty(type.type),
+							};
+						}
+						const typeName = (type as NamedTypeNode).name?.value;
+						const property = { type: typeName };
+						Object.defineProperty(property, 'location', { value: type.loc.startToken });
 						return property;
 					}
-					if (type.kind === 'ListType') {
-						return {
-							type: 'array',
-							elements: getProperty(type.type),
-						};
-					}
-					const typeName = (type as NamedTypeNode).name?.value;
-					const property = { type: typeName };
-					Object.defineProperty(property, 'location', { value: type.loc.startToken });
-					return property;
-				}
-				const attributesObject = {};
-				for (const field of definition.fields) {
-					const property = getProperty(field.type);
-					property.name = field.name.value;
-					properties.push(property);
-					attributesObject[property.name] = undefined; // this is used as a backup scope for computed properties
-					for (const directive of field.directives) {
-						const directiveName = directive.name.value;
-						if (directiveName === 'primaryKey') {
-							if (hasPrimaryKey) console.warn('Can not define two attributes as a primary key at', directive.loc);
-							else {
-								property.isPrimaryKey = true;
-								hasPrimaryKey = true;
-							}
-						} else if (directiveName === 'indexed') {
-							const indexedDefinition = {};
-							// store indexed arguments for configurable indexes.
-							for (const arg of directive.arguments || []) {
-								indexedDefinition[arg.name.value] = (arg.value as StringValueNode).value;
-							}
-							property.indexed = indexedDefinition;
-						} else if (directiveName === 'computed') {
-							for (const arg of directive.arguments || []) {
-								if (arg.name.value === 'from') {
-									const computedFromExpression = (arg.value as StringValueNode).value;
-									property.computed = {
-										from: createComputedFrom(computedFromExpression, arg, attributesObject),
-									};
-									// if the version is not defined, we use the computed from expression as the version, any changes to the computed from expression will trigger a version change and reindex
-									if (property.version == undefined) property.version = computedFromExpression;
-								} else if (arg.name.value === 'version') {
-									property.version = (arg.value as StringValueNode).value;
+					const attributesObject = {};
+					for (const field of definition.fields) {
+						const property = getProperty(field.type);
+						property.name = field.name.value;
+						properties.push(property);
+						attributesObject[property.name] = undefined; // this is used as a backup scope for computed properties
+						for (const directive of field.directives) {
+							const directiveName = directive.name.value;
+							if (directiveName === 'primaryKey') {
+								if (hasPrimaryKey) console.warn('Can not define two attributes as a primary key at', directive.loc);
+								else {
+									property.isPrimaryKey = true;
+									hasPrimaryKey = true;
 								}
-							}
-							property.computed = property.computed || true;
-						} else if (directiveName === 'relationship') {
-							const relationshipDefinition = {};
-							for (const arg of directive.arguments) {
-								relationshipDefinition[arg.name.value] = (arg.value as StringValueNode).value;
-							}
-							property.relationship = relationshipDefinition;
-						} else if (directiveName === 'createdTime') {
-							property.assignCreatedTime = true;
-						} else if (directiveName === 'updatedTime') {
-							property.assignUpdatedTime = true;
-						} else if (directiveName === 'expiresAt') {
-							property.expiresAt = true;
-						} else if (directiveName === 'enumerable') {
-							property.enumerable = true;
-						} else if (directiveName === 'allow') {
-							const authorizedRoles = (property.authorizedRoles = []);
-							for (const arg of directive.arguments) {
-								if (arg.name.value === 'role') {
-									authorizedRoles.push((arg.value as StringValueNode).value);
+							} else if (directiveName === 'indexed') {
+								const indexedDefinition = {};
+								// store indexed arguments for configurable indexes.
+								for (const arg of directive.arguments || []) {
+									indexedDefinition[arg.name.value] = (arg.value as StringValueNode).value;
+								}
+								property.indexed = indexedDefinition;
+							} else if (directiveName === 'computed') {
+								for (const arg of directive.arguments || []) {
+									if (arg.name.value === 'from') {
+										const computedFromExpression = (arg.value as StringValueNode).value;
+										property.computed = {
+											from: createComputedFrom(computedFromExpression, arg, attributesObject),
+										};
+										// if the version is not defined, we use the computed from expression as the version, any changes to the computed from expression will trigger a version change and reindex
+										if (property.version == undefined) property.version = computedFromExpression;
+									} else if (arg.name.value === 'version') {
+										property.version = (arg.value as StringValueNode).value;
+									}
 								}
+								property.computed = property.computed || true;
+							} else if (directiveName === 'relationship') {
+								const relationshipDefinition = {};
+								for (const arg of directive.arguments) {
+									relationshipDefinition[arg.name.value] = (arg.value as StringValueNode).value;
+								}
+								property.relationship = relationshipDefinition;
+							} else if (directiveName === 'createdTime') {
+								property.assignCreatedTime = true;
+							} else if (directiveName === 'updatedTime') {
+								property.assignUpdatedTime = true;
+							} else if (directiveName === 'expiresAt') {
+								property.expiresAt = true;
+							} else if (directiveName === 'enumerable') {
+								property.enumerable = true;
+							} else if (directiveName === 'allow') {
+								const authorizedRoles = (property.authorizedRoles = []);
+								for (const arg of directive.arguments) {
+									if (arg.name.value === 'role') {
+										authorizedRoles.push((arg.value as StringValueNode).value);
+									}
+								}
+							} else if (server.knownGraphQLDirectives.includes(directiveName)) {
+								console.warn(`@${directiveName} is an unknown directive, at`, directive.loc);
 							}
-						} else if (server.knownGraphQLDirectives.includes(directiveName)) {
-							console.warn(`@${directiveName} is an unknown directive, at`, directive.loc);
 						}
 					}
-				}
-				typeDef.type = typeName;
+					typeDef.type = typeName;
+			}
 		}
-	}
-	// check the types and if any types reference other types, fill those in.
-	function connectPropertyType(property) {
-		const targetTypeDef = types.get(property.type);
-		if (targetTypeDef) {
-			Object.defineProperty(property, 'properties', { value: targetTypeDef.properties });
-			Object.defineProperty(property, 'definition', { value: targetTypeDef });
-		} else if (property.type === 'array') connectPropertyType(property.elements);
-		else if (!PRIMITIVE_TYPES.includes(property.type)) {
-			if (getWorkerIndex() === 0)
-				console.error(
-					`The type ${property.type} is unknown at line ${property.location.line}, column ${property.location.column}, in ${filePath}`
-				);
+		// check the types and if any types reference other types, fill those in.
+		function connectPropertyType(property) {
+			const targetTypeDef = types.get(property.type);
+			if (targetTypeDef) {
+				Object.defineProperty(property, 'properties', { value: targetTypeDef.properties });
+				Object.defineProperty(property, 'definition', { value: targetTypeDef });
+			} else if (property.type === 'array') connectPropertyType(property.elements);
+			else if (!PRIMITIVE_TYPES.includes(property.type)) {
+				if (getWorkerIndex() === 0)
+					console.error(
+						`The type ${property.type} is unknown at line ${property.location.line}, column ${property.location.column}, in ${filePath}`
+					);
+			}
 		}
-	}
-	for (const typeDef of types.values()) {
-		for (const property of typeDef.properties) connectPropertyType(property);
-	}
-	// any tables that are defined in the schema can now be registered
-	for (const typeDef of tables) {
-		// with graphql database definitions, this is a declaration that the table should exist and that it
-		// should be created if it does not exist
-		typeDef.tableClass = table(typeDef);
-		if (typeDef.export) {
-			// allow empty string to be used to declare a table on the root path
-			if (typeDef.export.name === '') resources.set(dirname(urlPath), typeDef.tableClass);
-			else
-				resources.set(
-					dirname(urlPath) + '/' + (typeDef.export.name || typeDef.type),
-					typeDef.tableClass,
-					typeDef.export
-				);
+		for (const typeDef of types.values()) {
+			for (const property of typeDef.properties) connectPropertyType(property);
 		}
-	}
-	function createComputedFrom(computedFrom: string, arg: any, attributes: any) {
-		// Create a function from a computed "from" directive. This can look like:
-		// @computed(from: "fieldOne + fieldTwo")
-		// We use Node's built-in Script class to compile the function and run it in the context of the record object, which allows us to specify the source
-		const script = new Script(
-			// we use the inner with statement to allow the computed function to access the record object's properties directly as top level names
-			// we use the outer with statement with attributes as a fallback so any access to an attribute that isn't defined on the record still returns undefined (instead of a ReferenceError)
-			`function computed(attributes) { return function(record) { with(attributes) { with (record) { return ${computedFrom}; } } } } computed;`,
-			{
-				filename: filePath, // specify the file path and line position for better error messages/debugging
-				lineOffset: arg.loc.startToken.line - 1,
-				columnOffset: arg.loc.startToken.column,
+		// any tables that are defined in the schema can now be registered
+		for (const typeDef of tables) {
+			// with graphql database definitions, this is a declaration that the table should exist and that it
+			// should be created if it does not exist
+			typeDef.tableClass = ensureTable(typeDef);
+			if (typeDef.export) {
+				// allow empty string to be used to declare a table on the root path
+				if (typeDef.export.name === '') resources.set(dirname(urlPath), typeDef.tableClass);
+				else
+					resources.set(
+						dirname(urlPath) + '/' + (typeDef.export.name || typeDef.type),
+						typeDef.tableClass,
+						typeDef.export
+					);
 			}
-		);
-		return script.runInThisContext()(attributes); // run the script in the context of the current context/global and return the function we defined
+		}
+		function createComputedFrom(computedFrom: string, arg: any, attributes: any) {
+			// Create a function from a computed "from" directive. This can look like:
+			// @computed(from: "fieldOne + fieldTwo")
+			// We use Node's built-in Script class to compile the function and run it in the context of the record object, which allows us to specify the source
+			const script = new Script(
+				// we use the inner with statement to allow the computed function to access the record object's properties directly as top level names
+				// we use the outer with statement with attributes as a fallback so any access to an attribute that isn't defined on the record still returns undefined (instead of a ReferenceError)
+				`function computed(attributes) { return function(record) { with(attributes) { with (record) { return ${computedFrom}; } } } } computed;`,
+				{
+					filename: filePath, // specify the file path and line position for better error messages/debugging
+					lineOffset: arg.loc.startToken.line - 1,
+					columnOffset: arg.loc.startToken.column,
+				}
+			);
+			return script.runInThisContext()(attributes); // run the script in the context of the current context/global and return the function we defined
+		}
 	}
 }
 
+export const startOnMainThread = start;
 // useful for testing
-export const loadGQLSchema = (content) => processGraphQLSchema(content, null, null, new Resources());
+export const loadGQLSchema = (content) =>
+	start({ ensureTable: table }).handleFile(content, null, null, new Resources());

package/core/resources/indexes/HierarchicalNavigableSmallWorld.ts

@@ -1,4 +1,4 @@
-import { cosineDistance, euclideanDistance, dotProductDistance } from './vector.ts';
+import { cosineDistance, euclideanDistance } from './vector.ts';
 import { FLOAT32_OPTIONS } from 'msgpackr';
 import { loggerWithTag } from '../../utility/logging/logger.ts';
 import { ClientError } from '../../utility/errors/hdbError.js';
@@ -52,12 +52,7 @@ export class HierarchicalNavigableSmallWorld {
 			// (we would actually like to use float16 if it were available)
 			this.indexStore.encoder.useFloat32 = FLOAT32_OPTIONS.ALWAYS;
 		}
-		this.distance =
-			options?.distance === 'euclidean'
-				? euclideanDistance
-				: options?.distance === 'dotProduct'
-					? dotProductDistance
-					: cosineDistance;
+		this.distance = options?.distance === 'euclidean' ? euclideanDistance : cosineDistance;
 		if (options) {
 			// allow all the HNSW parameters to be configured/tuned
 			if (options.M !== undefined) {
@@ -474,7 +469,6 @@ export class HierarchicalNavigableSmallWorld {
 		let distanceFunction: (a: number[], b: number[]) => number;
 		if (distance === 'cosine') distanceFunction = cosineDistance;
 		else if (distance === 'euclidean') distanceFunction = euclideanDistance;
-		else if (distance === 'dotProduct') distanceFunction = dotProductDistance;
 		else if (distance) throw new ClientError('Unknown distance function');
 		else distanceFunction = this.distance;
 		if (!target) throw new ClientError('A target vector must be provided for an HNSW query');
@@ -664,12 +658,7 @@ export class HierarchicalNavigableSmallWorld {
 
 			let distanceFunction = this.distance;
 			if (sortDefinition.type)
-				distanceFunction =
-					sortDefinition.distance === 'euclidean'
-						? euclideanDistance
-						: sortDefinition.distance === 'dotProduct'
-							? dotProductDistance
-							: cosineDistance;
+				distanceFunction = sortDefinition.distance === 'euclidean' ? euclideanDistance : cosineDistance;
 			const distance = distanceFunction(sortDefinition.target, vector);
 			vectorDistances.set(entry, distance);
 			return distance;

package/core/resources/indexes/vector.ts

@@ -36,20 +36,3 @@ export function cosineDistance(a: number[], b: number[]): number {
 
 	return 1 - dotProduct / (magnitudeA * magnitudeB || 1);
 }
-
-export function dotProductDistance(a: number[], b: number[]): number {
-	if (!Array.isArray(a) || !Array.isArray(b)) {
-		throw new Error('Inner product comparison requires an array');
-	}
-
-	let dotProduct = 0;
-	const length = Math.max(a.length, b.length);
-
-	for (let i = 0; i < length; i++) {
-		const va = a[i] || 0;
-		const vb = b[i] || 0;
-		dotProduct += va * vb;
-	}
-
-	return -dotProduct;
-}

package/core/resources/loadEnv.ts

@@ -1,26 +1,22 @@
 import { parse } from 'dotenv';
 import logger from '../utility/logging/harper_logger.js';
-import { Scope } from '../components/Scope.ts';
 
-export function handleApplication(scope: Scope) {
-	const override = (scope.options.getAll() as { override?: boolean }).override ?? false;
-	scope.handleEntry((entry) => {
-		if (entry.eventType !== 'add') {
-			scope.requestRestart();
-			return;
-		}
-		logger.debug(`Loading env file: ${entry.absolutePath}`);
-		for (const [key, value] of Object.entries(parse(entry.contents))) {
-			if (process.env[key] !== undefined) {
-				logger.warn(`Environment variable conflict: ${key} from ${entry.absolutePath} is already set on process.env`);
-				if (override) {
-					logger.debug(`override option enabled. overriding environment variable: ${key}`);
-				} else {
-					continue;
+export function start({ override }: { override: boolean }) {
+	return {
+		handleFile: (contents, _, filePath) => {
+			logger.debug(`Loading env file: ${filePath}`);
+			for (const [key, value] of Object.entries(parse(contents))) {
+				if (process.env[key] !== undefined) {
+					logger.warn(`Environment variable conflict: ${key} from ${filePath} is already set on process.env`);
+					if (override) {
+						logger.debug(`override option enabled. overriding environment variable: ${key}`);
+					} else {
+						continue;
+					}
 				}
-			}
 
-			process.env[key] = value;
-		}
-	});
+				process.env[key] = value;
+			}
+		},
+	};
 }

package/core/resources/login.ts

@@ -1,8 +1,7 @@
 import { Resource } from './Resource.ts';
-import { Scope } from '../components/Scope.ts';
-export function handleApplication(scope: Scope) {
-	scope.resources.set('login', Login);
-	scope.resources.loginPath = (request) => {
+export function start({ resources }) {
+	resources.set('login', Login);
+	resources.loginPath = (request) => {
 		return '/login?redirect=' + encodeURIComponent(request.url);
 	};
 }