@harperfast/harper-pro 5.0.5 → 5.0.6

package/core/resources/DatabaseTransaction.ts

@@ -256,9 +256,14 @@ export class DatabaseTransaction implements Transaction {
 				if (!outstandingCommit) {
 					outstandingCommit = commitResolution;
 					outstandingCommitStart = performance.now();
-					outstandingCommit.finally(() => {
-						outstandingCommit = null;
-					});
+					outstandingCommit
+						// if `commitResolution` rejects with and `ERR_BUSY` error, the retry logic
+						// will correct course, but the reject will still be propagated on the
+						// `outstandingCommit` promise and needs to be caught and silenced
+						.catch(() => {})
+						.finally(() => {
+							outstandingCommit = null;
+						});
 				}
 				const completions = [];
 				return commitResolution.then(

package/core/resources/Table.ts

@@ -91,6 +91,7 @@ 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;
@@ -4038,15 +4039,14 @@ 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
-								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
+								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);
 								} else {
 									let headers: any;
 									const sourceHeaders = updatedRecord.headers;
@@ -4074,16 +4074,11 @@ 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,7 +184,6 @@ 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
@@ -368,7 +367,7 @@ function readRocksMetaDb(path: string, defaultTable?: string, databaseName: stri
 		if (rootStore) {
 			initStores(path, rootStore, databaseName, defaultTable);
 		} else {
-			rootStore = openRocksDatabase(path, { disableWAL: false }) as RocksDatabaseEx;
+			rootStore = openRocksDatabase(path, { disableWAL: false, enableStats: true }) as RocksDatabaseEx;
 			rocksdbDatabaseEnvs.set(path, rootStore);
 			initStores(path, rootStore, databaseName, defaultTable);
 			replayLogs(rootStore, databases[databaseName]);
@@ -723,6 +722,7 @@ export function database({ database: databaseName, table: tableName }) {
 		if (!rootStore || rootStore.status === 'closed') {
 			rootStore = openRocksDatabase(path, {
 				disableWAL: false,
+				enableStats: true,
 			});
 			rocksdbDatabaseEnvs.set(path, rootStore);
 		}

package/core/resources/graphql.ts

@@ -35,187 +35,185 @@ server.knownGraphQLDirectives.push(
  * @param filePath
  * @param resources
  */
-export function start({ ensureTable }) {
-	return {
-		handleFile,
-		setupFile: handleFile,
-	};
+export function handleApplication(scope: import('../components/Scope.ts').Scope) {
+	scope.handleEntry(async (entry) => {
+		if (entry.eventType === 'unlink') return;
+		await processGraphQLSchema(entry.contents, entry.urlPath, entry.absolutePath, scope.resources);
+	});
+}
 
-	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 (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;
-							}
+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;
 						}
+						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);
 					}
-					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),
-							};
+					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;
 						}
-						const typeName = (type as NamedTypeNode).name?.value;
-						const property = { type: typeName };
-						Object.defineProperty(property, 'location', { value: type.loc.startToken });
+					}
+				}
+				let hasPrimaryKey = false;
+				function getProperty(type) {
+					if (type.kind === 'NonNullType') {
+						const property = getProperty(type.type);
+						property.nullable = false;
 						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;
-									}
-								}
-								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;
+					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;
 								}
-								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);
-									}
+							}
+							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);
+	}
+	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
+				);
 		}
-		// 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
-					);
+	}
+	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,
 			}
-		}
-		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
-		}
+		);
+		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) =>
-	start({ ensureTable: table }).handleFile(content, null, null, new Resources());
+export const loadGQLSchema = (content) => processGraphQLSchema(content, null, null, new Resources());

package/core/resources/indexes/HierarchicalNavigableSmallWorld.ts

@@ -1,4 +1,4 @@
-import { cosineDistance, euclideanDistance } from './vector.ts';
+import { cosineDistance, euclideanDistance, dotProductDistance } from './vector.ts';
 import { FLOAT32_OPTIONS } from 'msgpackr';
 import { loggerWithTag } from '../../utility/logging/logger.ts';
 import { ClientError } from '../../utility/errors/hdbError.js';
@@ -52,7 +52,12 @@ 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 : cosineDistance;
+		this.distance =
+			options?.distance === 'euclidean'
+				? euclideanDistance
+				: options?.distance === 'dotProduct'
+					? dotProductDistance
+					: cosineDistance;
 		if (options) {
 			// allow all the HNSW parameters to be configured/tuned
 			if (options.M !== undefined) {
@@ -469,6 +474,7 @@ 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');
@@ -658,7 +664,12 @@ export class HierarchicalNavigableSmallWorld {
 
 			let distanceFunction = this.distance;
 			if (sortDefinition.type)
-				distanceFunction = sortDefinition.distance === 'euclidean' ? euclideanDistance : cosineDistance;
+				distanceFunction =
+					sortDefinition.distance === 'euclidean'
+						? euclideanDistance
+						: sortDefinition.distance === 'dotProduct'
+							? dotProductDistance
+							: cosineDistance;
 			const distance = distanceFunction(sortDefinition.target, vector);
 			vectorDistances.set(entry, distance);
 			return distance;

package/core/resources/indexes/vector.ts

@@ -36,3 +36,20 @@ 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,22 +1,26 @@
 import { parse } from 'dotenv';
 import logger from '../utility/logging/harper_logger.js';
+import { Scope } from '../components/Scope.ts';
 
-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;
-					}
+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;
 				}
-
-				process.env[key] = value;
 			}
-		},
-	};
+
+			process.env[key] = value;
+		}
+	});
 }

package/core/resources/login.ts

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