ok this basically works

Pckool · Pckool · commit 8f241ba204f9 · 2023-09-08T12:04:18.000-04:00
diff --git a/packages/plexus-core/src/action.ts b/packages/plexus-core/src/action.ts
@@ -111,21 +111,21 @@ export type InnerFunction<ResultFn extends FunctionType> = ResultFn extends (
 // export type PlexusAction = <ReturnData=FunctionType>(fn: FunctionType) => (...args: any) => ReturnData | Promise<ReturnData>
 export type PlexusAction = typeof _action
 
-export function _action<Response>(
+export function _action<Response, Fn extends FunctionType>(
 	instance: () => PlexusInstance,
-	fn: (...args: FunctionArgs) => Response,
+	fn: ((...args: FunctionArgs) => Response) & Fn,
 	batched?: boolean
 ): (...args: InnerFunctionArgs) => Response
 
-export function _action<Response>(
+export function _action<Response, Fn extends FunctionType>(
 	instance: () => PlexusInstance,
-	fn: (...args: FunctionArgs) => Promise<Response>,
+	fn: ((...args: FunctionArgs) => Promise<Response>) & Fn,
 	batched?: boolean
 ): (...args: InnerFunctionArgs) => Promise<Response>
 
-export function _action<Response>(
+export function _action<Response, Fn extends FunctionType>(
 	instance: () => PlexusInstance,
-	fn: (...args: FunctionArgs) => Promise<Response> | Response,
+	fn: ((...args: FunctionArgs) => Promise<Response> | Response) & Fn,
 	batched?: boolean
 ) {
 	const helpers = new PlexusActionHelpers(instance)
@@ -153,7 +153,6 @@ export function _action<Response>(
 					})
 				}
 			}
-			console.log('hewhewhewhewhewh', batched, args, 'hewhewhewhewhewh')
 			// if the action is batched, run it in a batch
 			if (batched) {
 				return instance().runtime.batch(() => fn(helpers.hooks, ...args))
@@ -164,6 +163,7 @@ export function _action<Response>(
 			// only return the error if there is no handler
 
 			if (!helpers.catchError && !instance()._globalCatch) {
+				console.log('error caught but returning', e)
 				if (e instanceof PlexusError) throw e
 				if (e instanceof Error) {
 					throw new PlexusError(
@@ -172,6 +172,7 @@ export function _action<Response>(
 					)
 				}
 			}
+			console.log('error caught', e)
 			helpers.runErrorHandlers(e)
 
 			// otherwise run the handler and return null
@@ -184,7 +185,7 @@ export function _action<Response>(
 		}
 	}
 	// return the proxy function
-	return newAction
+	return newAction as InnerFunction<Fn>
 	// return proxyFn as InnerFunction<Fn>
 
 	// const newAction = async (...args) => {
@@ -222,10 +223,12 @@ export function _action<Response>(
  * @param fn The Plexus action function to run
  * @returns The intended return value of fn, or null if an error is caught
  */
-export function action<Response>(fn: (...args: FunctionArgs) => Response)
+export function action<Response>(
+	fn: (...args: FunctionArgs) => Response
+): (...args: InnerFunctionArgs) => Response
 export function action<Response>(
 	fn: (...args: FunctionArgs) => Promise<Response>
-)
+): (...args: InnerFunctionArgs) => Promise<Response>
 export function action<Response>(
 	fn: (...args: FunctionArgs) => Promise<Response> | Response
 ) {
diff --git a/packages/plexus-core/src/instance/runtime.ts b/packages/plexus-core/src/instance/runtime.ts
@@ -238,12 +238,13 @@ export class RuntimeInstance {
 			}
 			// stop storing changes and emit the changes
 			this.batching = false
+			const unhalt = this.engine.halt()
 			// call all the pending functions and clear the array
 			this.batchedCalls.forEach((pendingFn) => pendingFn())
 			this.batchedCalls.length = 0
 
 			// release the reactivity engine
-			// unhalt()
+			unhalt()
 
 			this.instance().runtime.log('info', 'Batch function completed!')
 		}
diff --git a/packages/plexus-core/src/scope.ts b/packages/plexus-core/src/scope.ts
@@ -26,10 +26,7 @@ export class Scope {
 	// private _internalStore: PlexusScopeStore
 	public instance: () => PlexusInstance
 
-	constructor(
-		public name: string,
-		config?: PlexusScopeConfig
-	) {
+	constructor(public name: string, config?: PlexusScopeConfig) {
 		if (!name || name.length === 0) {
 			throw new Error('Scope name is required')
 		}
@@ -93,17 +90,17 @@ export class Scope {
 	 * @param fn The Plexus action function to run
 	 * @returns The intended return value of fn, or null if an error is caught
 	 */
-	action<Fn extends FunctionType>(fn: Fn) {
-		return _action<Fn>(this.instance, fn)
-	}
-	/**
-	 * Generate a Plexus Action
-	 * @param fn The Plexus action function to run
-	 * @returns The intended return value of fn, or null if an error is caught
-	 */
-	batchAction<Fn extends FunctionType>(fn: Fn) {
-		return _action<Fn>(this.instance, fn, true)
-	}
+	// action<Fn extends FunctionType>(fn: Fn) {
+	// 	return _action<Fn>(this.instance, fn)
+	// }
+	// /**
+	//  * Generate a Plexus Action
+	//  * @param fn The Plexus action function to run
+	//  * @returns The intended return value of fn, or null if an error is caught
+	//  */
+	// batchAction<Fn extends FunctionType>(fn: Fn) {
+	// 	return _action<Fn>(this.instance, fn, true)
+	// }
 	/**
 	 * Run a function. During that function's execution, any state changes will be batched and only applied once the function has finished.
 	 * @param fn The function to run in a batch
diff --git a/packages/plexus-utils/src/shared/index.ts b/packages/plexus-utils/src/shared/index.ts
@@ -6,9 +6,12 @@ export const genUID = () =>
 	Math.random().toString(36).substring(2, 15) +
 	Math.random().toString(36).substring(2, 15)
 
-export const isAsyncFunction = <ReturnedValue>(
-	fn: (...args: any[]) => ReturnedValue | Promise<ReturnedValue>
-): fn is () => Promise<ReturnedValue> =>
+export const isAsyncFunction = <
+	ReturnedValue,
+	Args extends Array<unknown> = any[]
+>(
+	fn: (...args: Args) => ReturnedValue | Promise<ReturnedValue>
+): fn is (...args: Args) => Promise<ReturnedValue> =>
 	typeof fn === 'function' &&
 	(fn.constructor.name === 'AsyncFunction' ||
 		fn[Symbol.toStringTag] === 'AsyncFunction')
diff --git a/tests/action.test.ts b/tests/action.test.ts
@@ -73,14 +73,14 @@ describe('Testing Action Function', () => {
 	})
 
 	test(`Can handle async errors`, async () => {
+		let counter = 0
 		const myAction = action(async ({ onCatch }) => {
-			onCatch(() => {
-				console.log('error caught successfully!')
-			})
-			return await new Promise((resolve, reject) => {
-				setTimeout(() => reject(new Error('test error')), 100)
-			})
+			onCatch(console.error)
+			counter++
+			if (counter === 2) throw new Error('test error')
 		})
+
+		await myAction()
 		const data = await myAction()
 		expect(data).toBeDefined()
 	})
diff --git a/tests/efficiency.test.ts b/tests/efficiency.test.ts
@@ -25,7 +25,7 @@ const users1kRelated = Array.from(
 			id: randUuid(),
 			firstName: randFirstName(),
 			appointmentId: randUuid(),
-		}) as User
+		} as User)
 )
 
 const appointments1kRelated = users1kRelated.map(
@@ -35,7 +35,7 @@ const appointments1kRelated = users1kRelated.map(
 			userId: user.id,
 			date: randFutureDate().getTime(),
 			name: randBook().title,
-		}) as Appointment
+		} as Appointment)
 )
 
 // check the .cache directory for the generated data. If it doesn't exist, it will be generated. Need users1k.json, users10k.json, users10kRelated.json, appointments10kRelated.json
@@ -51,52 +51,40 @@ afterEach(() => {
 })
 
 describe('Efficiency tests for ', () => {
-	// test('The speed of a plexus collection collecting more than a thousand randomly generated objects into multiple groups', () => {
-	// 	instance({ logLevel: 'debug' })
-	// 	console.log('Starting test...')
-	// 	console.log('items in collection:', users1k.length)
-	// 	usersLite.collect(users1k, ['firstNames'])
-	// 	console.log('items in collection:', usersLite.value.length)
-	// 	expect(usersLite.value.length).toBe(1000)
-	// 	expect(usersLite.groups.firstNames.value.length).toBe(1000)
-	// 	instance({ logLevel: undefined })
-	// })
-	// test('Testing the same as above but with an absurd amount of data', () => {
-	// 	instance({ logLevel: 'debug' })
-	// 	console.log('Starting test...')
-	// 	console.log('items in collection:', users10k.length)
-	// 	usersLite.collect(users10k, ['firstNames'])
-	// 	console.log('items in collection:', usersLite.value.length)
-	// 	// const group1 = collectionInstance.group('appointmentId')
-	// 	// const group2 = collectionInstance.group('name')
-	// 	// expect(group1.value.length).toBe(1000)
-	// 	// expect(group2.value.length).toBe(1000)
-	// 	instance({ logLevel: undefined })
-	// })
-	// test('An absurd amount of related data', () => {
-	// 	instance({ logLevel: 'debug' })
-	// 	console.log('Starting test...')
-	// 	console.log('items in collection:', users10k.length)
-	// 	users.collect(users1kRelated, ['main'])
-	// 	appointments.collect(appointments1kRelated, ['main'])
-	// 	console.log('items in collection:', users.value.length)
-	// 	// const group1 = collectionInstance.group('appointmentId')
-	// 	// const group2 = collectionInstance.group('name')
-	// 	// expect(group1.value.length).toBe(1000)
-	// 	// expect(group2.value.length).toBe(1000)
-	// 	instance({ logLevel: undefined })
-	// })
-	// test('An absurd amount of related data', () => {
-	// 	instance({ logLevel: 'debug' })
-	// 	console.log('Starting test...')
-	// 	console.log('items in collection:', users10k.length)
-	// 	users.collect(users1kRelated, ['main'])
-	// 	appointments.collect(appointments1kRelated, ['main'])
-	// 	console.log('items in collection:', users.value.length)
-	// 	// const group1 = collectionInstance.group('appointmentId')
-	// 	// const group2 = collectionInstance.group('name')
-	// 	// expect(group1.value.length).toBe(1000)
-	// 	// expect(group2.value.length).toBe(1000)
-	// 	instance({ logLevel: undefined })
-	// })
+	test('The speed of a plexus collection collecting more than a thousand randomly generated objects into multiple groups', () => {
+		instance({ logLevel: 'debug' })
+		console.log('Starting test...')
+		console.log('items in collection:', users1k.length)
+		usersLite.collect(users1k, ['firstNames'])
+		console.log('items in collection:', usersLite.value.length)
+		expect(usersLite.value.length).toBe(1000)
+		expect(usersLite.groups.firstNames.value.length).toBe(1000)
+
+		instance({ logLevel: undefined })
+	})
+	test('Testing the same as above but with an absurd amount of data', () => {
+		instance({ logLevel: 'debug' })
+		console.log('Starting test...')
+		console.log('items in collection:', users10k.length)
+		usersLite.collect(users10k, ['firstNames'])
+		console.log('items in collection:', usersLite.value.length)
+		// const group1 = collectionInstance.group('appointmentId')
+		// const group2 = collectionInstance.group('name')
+		// expect(group1.value.length).toBe(1000)
+		// expect(group2.value.length).toBe(1000)
+		instance({ logLevel: undefined })
+	})
+	test('An absurd amount of related data', () => {
+		instance({ logLevel: 'debug' })
+		console.log('Starting test...')
+		console.log('items in collection:', users10k.length)
+		users.collect(users1kRelated, ['main'])
+		appointments.collect(appointments1kRelated, ['main'])
+		console.log('items in collection:', users.value.length)
+		// const group1 = collectionInstance.group('appointmentId')
+		// const group2 = collectionInstance.group('name')
+		// expect(group1.value.length).toBe(1000)
+		// expect(group2.value.length).toBe(1000)
+		instance({ logLevel: undefined })
+	})
 })
diff --git a/tests/test-utils.tsx b/tests/test-utils.tsx
@@ -88,7 +88,7 @@ export const uniqueGroups = collection<UserLiteExplicitIdName>({
 	uniqueGroups: true,
 }).createSelector('batched')
 
-export const DEFAULT_DECAY_RATE = 12_000
+export const DEFAULT_DECAY_RATE = 1_000
 export const decayingUsers = collection<UserLiteExplicitIdName>({
 	primaryKey: 'userId',
 	name: 'userslite',
diff --git a/tests/timed.test.ts b/tests/timed.test.ts
@@ -1,53 +1,53 @@
-import { describe, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { DEFAULT_DECAY_RATE, decayingUsers } from './test-utils'
 
 describe('Ephemeral Collection data', () => {
-	// test(
-	// 	'Does decaying data work?',
-	// 	(ctx) =>
-	// 		new Promise((resolve) => {
-	// 			decayingUsers.collect({ firstName: 'Bill', userId: '0' })
-	// 			expect(decayingUsers.value.length).toBe(1)
-	// 			expect(decayingUsers.value[0].firstName).toBe('Bill')
-	// 			expect(decayingUsers.value[0].userId).toBe('0')
-	// 			setTimeout(() => {
-	// 				expect(decayingUsers.value.length).toBe(0)
-	// 				console.log('done! Thing is decayed!')
-	// 				resolve(true)
-	// 			}, DEFAULT_DECAY_RATE + 10)
-	// 		}),
-	// 	DEFAULT_DECAY_RATE + 100
-	// )
-	// test(
-	// 	'Does decaying data refresh on set?',
-	// 	(ctx) =>
-	// 		new Promise((resolve) => {
-	// 			decayingUsers.collect({ firstName: 'Bill', userId: '0' })
-	// 			expect(decayingUsers.value.length).toBe(1)
-	// 			expect(decayingUsers.value[0].firstName).toBe('Bill')
-	// 			expect(decayingUsers.value[0].userId).toBe('0')
-	// 			// recollecting should reset the decay timer
-	// 			setTimeout(() => {
-	// 				expect(decayingUsers.value.length).toBe(1)
-	// 				decayingUsers.collect({ firstName: 'Bill', userId: '0' })
-	// 			}, DEFAULT_DECAY_RATE - 10)
-	// 			// so if we wait a bit, it should still be there
-	// 			setTimeout(() => {
-	// 				console.log('wtfff')
-	// 				expect(decayingUsers.value.length).toBe(1)
-	// 			}, DEFAULT_DECAY_RATE + 10)
-	// 			// and then it should decay past the decay rate
-	// 			setTimeout(
-	// 				() => {
-	// 					expect(decayingUsers.value.length).toBe(0)
-	// 					console.log('done! Thing is decayed!')
-	// 					resolve(true)
-	// 				},
-	// 				DEFAULT_DECAY_RATE * 2 + 10
-	// 			)
-	// 		}),
-	// 	{
-	// 		timeout: DEFAULT_DECAY_RATE * 2 + 100,
-	// 	}
-	// )
+	test(
+		'Does decaying data work?',
+		(ctx) =>
+			new Promise((resolve) => {
+				decayingUsers.collect({ firstName: 'Bill', userId: '0' })
+				expect(decayingUsers.value.length).toBe(1)
+				expect(decayingUsers.value[0].firstName).toBe('Bill')
+				expect(decayingUsers.value[0].userId).toBe('0')
+				setTimeout(() => {
+					expect(decayingUsers.value.length).toBe(0)
+					console.log('done! Thing is decayed!')
+					resolve(true)
+				}, DEFAULT_DECAY_RATE + 10)
+			}),
+		DEFAULT_DECAY_RATE + 100
+	)
+	test(
+		'Does decaying data refresh on set?',
+		(ctx) =>
+			new Promise((resolve) => {
+				decayingUsers.collect({ firstName: 'Bill', userId: '0' })
+				expect(decayingUsers.value.length).toBe(1)
+				expect(decayingUsers.value[0].firstName).toBe('Bill')
+				expect(decayingUsers.value[0].userId).toBe('0')
+				// recollecting should reset the decay timer
+				setTimeout(() => {
+					expect(decayingUsers.value.length).toBe(1)
+					decayingUsers.collect({ firstName: 'Bill', userId: '0' })
+				}, DEFAULT_DECAY_RATE - 10)
+				// so if we wait a bit, it should still be there
+				setTimeout(() => {
+					console.log('wtfff')
+					expect(decayingUsers.value.length).toBe(1)
+				}, DEFAULT_DECAY_RATE + 10)
+				// and then it should decay past the decay rate
+				setTimeout(
+					() => {
+						expect(decayingUsers.value.length).toBe(0)
+						console.log('done! Thing is decayed!')
+						resolve(true)
+					},
+					DEFAULT_DECAY_RATE * 2 + 10
+				)
+			}),
+		{
+			timeout: DEFAULT_DECAY_RATE * 2 + 100,
+		}
+	)
 })

Original file line number	Diff line number	Diff line change
`@@ -238,12 +238,13 @@ export class RuntimeInstance {`
`238`	`238`	`}`
`239`	`239`	`// stop storing changes and emit the changes`
`240`	`240`	`this.batching = false`
	`241`	`+ const unhalt = this.engine.halt()`
`241`	`242`	`// call all the pending functions and clear the array`
`242`	`243`	`this.batchedCalls.forEach((pendingFn) => pendingFn())`
`243`	`244`	`this.batchedCalls.length = 0`
`244`	`245`
`245`	`246`	`// release the reactivity engine`
`246`		`- // unhalt()`
	`247`	`+ unhalt()`
`247`	`248`
`248`	`249`	`this.instance().runtime.log('info', 'Batch function completed!')`
`249`	`250`	`}`