fixed controllers too

Author: Pckool

packages/plexus-core/src/error.ts

@@ -1,38 +1,42 @@
 import { PlexusInstance } from './instance/instance'
 
+type PlexusErrorOptions = { code: string; source: string; stack: string }
+
 export class PlexusError extends Error {
 	public name = 'PlexusError'
 	public error = true
-	constructor(
-		message: string,
-		public options?: Partial<{ code: string; origin: string; stack: string }>
-	) {
+	constructor(message: string, public options?: Partial<PlexusErrorOptions>) {
 		super(message)
 	}
 	// custom error format for logging and debugging
 	toString() {
-		return `PlexusError: ${this.message} (${this.options?.code ?? 'NO_CODE'})`
+		return `PlexusError${
+			this.options?.source ? `(${this.options.source})` : ''
+		}${this.options?.code ? `[${this.options?.code}]` : ''}: ${this.message}`
 	}
 }
-export function handlePlexusError(e: unknown | Error | string): PlexusError {
+export function handlePlexusError(
+	e: unknown | Error | string,
+	options?: Partial<PlexusErrorOptions>
+): PlexusError {
 	if (typeof e === 'string') {
-		return new PlexusError(e)
+		return new PlexusError(e, options)
 	}
 
 	// error-like objects
 	if (e instanceof PlexusError) return e
 	if (e instanceof Error) {
 		return new PlexusError(
 			`An error occurred during the execution of an action (${e.message})`,
-			{ origin: 'action', stack: e.stack }
+			{ ...options, stack: e.stack }
 		)
 	}
 
 	// generic error
 	return new PlexusError(
 		'An error occurred during the execution of an action',
 		{
-			origin: 'action',
+			...options,
 		}
 	)
 }

packages/plexus-core/src/instance/controller.ts

@@ -1,5 +1,6 @@
 import type { PlexusCollectionInstance } from '../collection/collection'
 import type { PlexusComputedStateInstance } from '../computed'
+import { handlePlexusError } from '../error'
 import type { PlexusEventInstance } from '../event'
 import type { PlexusStateInstance } from '../state'
 import { PlexusInstance, instance } from './instance'
@@ -13,56 +14,93 @@ type PlexusItem =
 type PlexusRecord<T> = {
 	[key: string]: T | PlexusItem
 }
+
+type PlexusIdMap<T> = {
+	[key: string]: T | string
+}
+type ControllerOptions<OriginalObject = PlexusRecord<any>> = {
+	instance: () => PlexusInstance
+	id: string
+	data: OriginalObject
+}
 /**
  * Plexus Controller can be used to create a controller for a module within your plexus core.
  * Pass an object that can be many layers deep. Each key is the name of a plexus item (state, action, etc) and the value is the instance of the item.
  */
 export class ControllerInstance<OriginalObject extends PlexusRecord<any>> {
-	public readonly name: string
-	public readonly path: string
+	private readonly id: string
+	private path: string | null = null
 	public readonly instance: () => PlexusInstance
 	protected readonly moduleStore: OriginalObject
-	private linkedIds: Map<string, string[]> = new Map()
+	private linkedIds: Record<
+		string,
+		string | ControllerInstance<PlexusRecord<any>>
+	> = Object.freeze({})
 
-	constructor(
-		instance: () => PlexusInstance,
-		name: string,
-		data: OriginalObject
-	) {
-		this.name = name
-		this.path = name
+	constructor(public name: string, options: ControllerOptions<OriginalObject>) {
+		const { instance, id, data } = options
+		this.id = id
 		this.instance = instance
 		this.moduleStore = data
 		this.create(data)
 	}
-	static parseObject(name: string, data: PlexusRecord<any>) {
+
+	static parseModule(data: PlexusRecord<any>) {
 		const names = Object.keys(data)
+		const values = names.map((name) => this.parseItem(name, data))
+		return Object.fromEntries(values)
+	}
+
+	static parseItem(name: string, data: PlexusRecord<any>) {
 		const item = data[name]
-		const id = item.id
+		if (item instanceof ControllerInstance) {
+			return [name, item.linkedIds]
+		}
+		const id: string = item?.id
 		if (!id) {
-			throw new Error(
-				`Plexus Controller: ${this.name} - ${name} is missing an id`
-			)
+			throw handlePlexusError(`${name} is missing an id`, {
+				source: this.name,
+			})
 		}
 		item.name = name
-		return [name, [id]]
+		return [name, id]
 	}
 	/**
 	 * Intake data, get the object id's, link them to the name, assign the names to the instance in the key's value, and save the mapping to the controller
 	 * @param data
 	 */
 	create(data: OriginalObject) {
-		const mapping = ControllerInstance.parseObject(this.name, data)
+		const mapping = ControllerInstance.parseModule(data)
 
-		// this.linkedIds = new Map(mapping)
+		this.linkedIds = Object.freeze({ ...mapping })
 	}
 
 	get module() {
 		return this.moduleStore as OriginalObject
 	}
 }
+export function controller<OriginalObject extends PlexusRecord<any>>(
+	name: string,
+	data: OriginalObject
+)
 export function controller<OriginalObject extends PlexusRecord<any>>(
 	data: OriginalObject
+)
+export function controller<OriginalObject extends PlexusRecord<any>>(
+	nameOrData: string | OriginalObject,
+	data?: OriginalObject
 ) {
-	return new ControllerInstance(() => instance(), instance().genId(), data)
+	const id = instance().genId()
+	if (typeof nameOrData === 'string') {
+		return new ControllerInstance(nameOrData, {
+			instance: () => instance(),
+			id,
+			data: data || {},
+		})
+	}
+	return new ControllerInstance(id, {
+		instance: () => instance(),
+		id,
+		data: nameOrData,
+	})
 }

tests/controller.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, afterEach, describe, test, expect,  } from 'vitest'
+import { beforeEach, afterEach, describe, test, expect } from 'vitest'
 
 import {
 	batchAction,
@@ -20,14 +20,17 @@ beforeEach(() => {
 })
 
 describe('Controller Basics', () => {
-	// test('can a controller be used', () => {
-	// 	const myModule = controller({
-	// 		myState: state('hey there'),
-	// 	}).export()
-
-	// 	expect(myModule.myState).toBeDefined()
-	// 	expect(myModule.myState.value).toBe('hey there')
-	// })
+	test('can a controller be used', () => {
+		const myController = controller('myController', {
+			myState: state('hey there'),
+		})
+		const myModule = myController.module
+
+		expect(myModule.myState).toBeDefined()
+		expect(myModule.myState.value).toBe('hey there')
+
+		expect(myController.name).toBe('myController')
+	})
 	test('can a controller be used with .module', () => {
 		const myModule = controller({
 			myState: state('hey there'),