fix: Cut table TS errors in half

Author: dawsontoth

resources/ResourceInterface.ts

@@ -214,11 +214,15 @@ export interface SubSelect {
 }
 export type Select = (string | SubSelect)[];
 
-export interface SubscriptionRequest extends RequestTarget {
-	/** The starting time of events to return (defaults to now) */
+export interface SubscriptionRequest extends Partial<RequestTarget> {
+	/** The starting time of events to return (now is the default) */
 	startTime?: number;
 	/** The count of previously recorded events to return */
 	previousCount?: number;
+	/** Indicates that all threads are (presumably) making this subscription and we do not need to propagate events across threads (more efficient) */
+	crossThreads?: boolean;
+	/** Indicates that we want, if possible, immediate notification of writes within the process (not supported yet) */
+	inTransactionUpdates?: boolean;
 	/** If the current record state should be omitted as the first event */
 	omitCurrent?: boolean;
 	onlyChildren?: boolean;

resources/Table.ts

@@ -126,7 +126,7 @@ export function makeTable(options): TableStaticInterface {
 	const updateRecord = recordUpdater(primaryStore, tableId, auditStore);
 	let sourceLoad: any; // if a source has a load function (replicator), record it here
 	let hasSourceGet: any;
-	let primaryKeyAttribute: Attribute = {};
+	let primaryKeyAttribute: Attribute | null = null;
 	let lastEvictionCompletion: Promise<void> = Promise.resolve();
 	let createdTimeProperty: Attribute, updatedTimeProperty: Attribute, expiresAtProperty: Attribute;
 	for (const attribute of attributes) {
@@ -188,6 +188,8 @@ export function makeTable(options): TableStaticInterface {
 		}
 	}
 	class TableResource<Record extends object = any> extends Resource<Record> implements TableInterface<Record> {
+		['constructor']: typeof TableResource;
+
 		#record: any; // the stored/frozen record from the database and stored in the cache (should not be modified directly)
 		#changes: any; // the changes to the record that have been made (should not be modified directly)
 		#version?: number; // version of the record
@@ -230,10 +232,7 @@ export function makeTable(options): TableStaticInterface {
 		 * @param options
 		 * @returns
 		 */
-		static sourcedFrom<Record extends object = any>(
-			source: TableInterface<Record> & TableStaticInterface<Record>,
-			options?: ExpirationOptions & IntermediateSourceOptions
-		) {
+		static sourcedFrom(source: typeof TableResource, options?: ExpirationOptions & IntermediateSourceOptions) {
 			// define a source for retrieving invalidated entries for caching purposes
 			if (options) {
 				this.sourceOptions = options;
@@ -253,7 +252,7 @@ export function makeTable(options): TableStaticInterface {
 				this.source = source;
 			}
 			hasSourceGet = hasSourceGet || (source.get && (!source.get.reliesOnPrototype || source.prototype.get));
-			sourceLoad = sourceLoad || source.load;
+			sourceLoad = sourceLoad || (source as any).load;
 			const shouldRevalidateEvents = this.source?.shouldRevalidateEvents;
 
 			// External data source may provide a subscribe method, allowing for real-time proactive delivery
@@ -268,7 +267,7 @@ export function makeTable(options): TableStaticInterface {
 				// perform the write of an individual write event
 				const writeUpdate = async (event, context) => {
 					const value = event.value;
-					const Table = event.table ? databases[databaseName][event.table] : TableResource;
+					const Table = (event.table ? databases[databaseName][event.table] : TableResource) as typeof TableResource;
 					if (
 						databaseName === SYSTEM_SCHEMA_NAME &&
 						(event.table === SYSTEM_TABLE_NAMES.ROLE_TABLE_NAME || event.table === SYSTEM_TABLE_NAMES.USER_TABLE_NAME)
@@ -289,7 +288,7 @@ export function makeTable(options): TableStaticInterface {
 						async: true,
 					};
 					const id = event.id;
-					const resource: TableResource = await Table.getResource(id, context, options);
+					const resource = await Table.getResource(id, context, options);
 					if (event.finished) await event.finished;
 					switch (event.type) {
 						case 'put':
@@ -318,16 +317,10 @@ export function makeTable(options): TableStaticInterface {
 					const hasSubscribe = source.subscribe;
 					// if subscriptions come in out-of-order, we need to track deletes to ensure consistency
 					if (hasSubscribe && trackDeletes == undefined) trackDeletes = true;
-					const subscriptionOptions = {
-						// this is used to indicate that all threads are (presumably) making this subscription
-						// and we do not need to propagate events across threads (more efficient)
+					const subscriptionOptions: SubscriptionRequest = {
 						crossThreads: false,
-						// this is used to indicate that we want, if possible, immediate notification of writes
-						// within the process (not supported yet)
 						inTransactionUpdates: true,
-						// supports transaction operations
 						supportsTransactions: true,
-						// don't need the current state, should be up-to-date
 						omitCurrent: true,
 					};
 					const subscribeOnThisThread = source.subscribeOnThisThread
@@ -523,11 +516,7 @@ export function makeTable(options): TableStaticInterface {
 			}
 			return resource;
 		}
-		_loadRecord<Record extends object = any>(
-			target: RequestTarget,
-			request: Context,
-			resourceOptions?: any
-		): MaybePromise<TableResource<Record>> {
+		_loadRecord(target: RequestTarget, request: Context, resourceOptions?: any): MaybePromise<TableResource<Record>> {
 			const id = target && typeof target === 'object' ? target.id : target;
 			if (id == null) return this;
 			checkValidId(id);
@@ -907,17 +896,18 @@ export function makeTable(options): TableStaticInterface {
 		 * This retrieves the data of this resource.
 		 * @param target - If included, is an identifier/query that specifies the requested target to retrieve and query
 		 */
-		get(target: RequestTargetOrId): Record | AsyncIterable<Record> | Promise<Record | AsyncIterable<Record>>;
+		get(target: RequestTargetOrId): AsyncIterable<Record> | Promise<Record>;
 		get(
-			target?: RequestTargetOrId
+			targetOrId?: RequestTargetOrId
 		): TableResource<Record> | undefined | Record | AsyncIterable<Record> | Promise<Record | AsyncIterable<Record>> {
-			const constructor: Resource = this.constructor;
-			if (typeof target === 'string' && constructor.loadAsInstance !== false) return this.getProperty(target);
-			if (isSearchTarget(target)) {
+			const constructor = this.constructor;
+			if (typeof targetOrId === 'string' && constructor.loadAsInstance !== false) return this.getProperty(targetOrId);
+			if (isSearchTarget(targetOrId)) {
 				// go back to the static search method so it gets a chance to override
-				return constructor.search(target, this.getContext());
+				return constructor.search(targetOrId, this.getContext());
 			}
-			if (target && target.id === undefined && !target.toString()) {
+			const target = targetOrId as unknown as RequestTarget | undefined;
+			if (target?.id === undefined && !target.toString()) {
 				const description = {
 					// basically a describe call
 					records: './', // an href to the records themselves
@@ -1009,7 +999,7 @@ export function makeTable(options): TableStaticInterface {
 		/**
 		 * Determine if the user is allowed to get/read data from the current resource
 		 */
-		allowRead(user: User, target: RequestTarget, context: Context): boolean {
+		allowRead(user: User, target: Pick<RequestTarget, 'select' | 'checkPermission'>, context: Context): boolean {
 			const tablePermission = getTablePermissions(user, target);
 			if (tablePermission?.read) {
 				if (tablePermission.isSuperUser) return true;
@@ -1300,15 +1290,13 @@ export function makeTable(options): TableStaticInterface {
 			const context = this.getContext();
 			checkValidId(id);
 			const transaction = txnForContext(this.getContext());
+			const source: any = this.constructor.source;
 			transaction.addWrite({
 				key: id,
 				store: primaryStore,
 				invalidated: true,
 				entry: this.#entry,
-				before:
-					this.constructor.source?.relocate && !context?.source
-						? this.constructor.source.relocate.bind(this.constructor.source, id, undefined, context)
-						: undefined,
+				before: source?.relocate && !context?.source ? source.relocate.bind(source, id, undefined, context) : undefined,
 				commit: (txnTime, existingEntry, _retry, transaction: any) => {
 					if (precedesExistingVersion(txnTime, existingEntry, options?.nodeId) <= 0) return;
 					const residency = TableResource.getResidencyRecord(options.residencyId);
@@ -1885,7 +1873,7 @@ export function makeTable(options): TableStaticInterface {
 			if (target) {
 				let allowed = true;
 				const context = this.getContext();
-				if (target.checkPermission) {
+				if ((target as RequestTarget).checkPermission) {
 					// requesting authorization verification
 					allowed = this.allowDelete(context.user, target, context);
 				}
@@ -3546,8 +3534,11 @@ export function makeTable(options): TableStaticInterface {
 		if (length > MAX_KEY_BYTES) throw new Error('Primary key size is too large: ' + id.length);
 		return true;
 	}
-	function requestTargetToId(target: RequestTargetOrId): Id {
-		return typeof target === 'object' && target ? target.id : (target as Id);
+	function requestTargetToId(target: Partial<RequestTargetOrId>): Id {
+		return typeof target === 'object' && target ? (target as RequestTarget).id : (target as Id);
+	}
+	function isId(target: RequestTargetOrId): target is Id {
+		return target !== undefined && typeof target !== 'object';
 	}
 	function isSearchTarget(target: RequestTargetOrId): target is RequestTarget {
 		return typeof target === 'object' && target && (target as RequestTarget).isCollection;
@@ -3688,7 +3679,7 @@ export function makeTable(options): TableStaticInterface {
 			}
 		});
 	}
-	function getTablePermissions(user: User, target?: RequestTarget) {
+	function getTablePermissions(user: User, target?: Pick<RequestTarget, 'checkPermission'>) {
 		let permission = target?.checkPermission; // first check to see the request target specifically provides the permissions to authorize
 		if (typeof permission !== 'object') {
 			if (!user?.role) return;
@@ -4165,12 +4156,12 @@ export function makeTable(options): TableStaticInterface {
 	 * Verify that the context does not have any replication parameters that are not allowed
 	 * @param context
 	 */
-	function checkContextPermissions(context: Context): boolean {
+	function checkContextPermissions(context: Context | SourceContext): boolean {
 		if (!context) return true;
-		if (context.user?.role?.permission?.super_user) return true;
-		if (context.replicateTo)
+		if ((context as Context).user?.role?.permission?.super_user) return true;
+		if ((context as Context).replicateTo)
 			throw new ClientError('Can not specify replication parameters without super user permissions', 403);
-		if (context.replicatedConfirmation)
+		if ((context as Context).replicatedConfirmation)
 			throw new ClientError('Can not specify replication confirmation without super user permissions', 403);
 		return true;
 	}