feat(injecta): supported typed use and auto name use

Author: nekomeowww

apps/stage-tamagotchi/src/main/index.ts

@@ -108,11 +108,24 @@ async function setupProjectAIRIServerRuntime() {
 app.whenReady().then(async () => {
   await setupProjectAIRIServerRuntime()
 
-  injecta.setLogger(createLoggLogger())
-  injecta.provide('windows:settings', () => setupSettingsWindowReusableFunc())
-  injecta.provide<{ settingsWindow: () => Promise<BrowserWindow> }>('windows:main', { dependsOn: { settingsWindow: 'windows:settings' }, build: async ({ dependsOn }) => setupMainWindow(dependsOn) })
-  injecta.provide<{ mainWindow: BrowserWindow, settingsWindow: () => Promise<BrowserWindow> }>('tray', { dependsOn: { mainWindow: 'windows:main', settingsWindow: 'windows:settings' }, build: async ({ dependsOn }) => setupTray(dependsOn) })
-  injecta.invoke({ dependsOn: { mainWindow: 'windows:main', tray: 'tray' }, callback: noop })
+  injecta.setLogger(createLoggLogger(useLogg('injecta').useGlobalConfig()))
+
+  const settingsWindow = injecta.provide('windows:settings', {
+    build: () => setupSettingsWindowReusableFunc(),
+  })
+  const mainWindow = injecta.provide('windows:main', {
+    dependsOn: { settingsWindow },
+    build: async ({ dependsOn }) => setupMainWindow(dependsOn),
+  })
+  const tray = injecta.provide('app:tray', {
+    dependsOn: { mainWindow, settingsWindow },
+    build: async ({ dependsOn }) => setupTray(dependsOn),
+  })
+  injecta.invoke({
+    dependsOn: { mainWindow, tray },
+    callback: noop,
+  })
+
   injecta.start()
 
   // Lifecycle

package.json

@@ -99,6 +99,7 @@
       "@parcel/watcher",
       "bufferutil",
       "electron",
+      "electron-click-drag-plugin",
       "es5-ext",
       "esbuild",
       "ffmpeg-static",

packages/injecta/package.json

@@ -24,7 +24,9 @@
     "typecheck": "tsc --noEmit",
     "build": "tsdown"
   },
-  "dependencies": {
-    "@guiiai/logg": "catalog:"
+  "devDependencies": {
+    "@guiiai/logg": "catalog:",
+    "error-stack-parser": "^2.1.4",
+    "nanoid": "^5.1.6"
   }
 }

packages/injecta/src/global.test.ts

@@ -0,0 +1,187 @@
+import type { Lifecycle } from './builtin'
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { invoke, provide, resetContainer, start, stop } from './global'
+import { lifecycle } from './scoped'
+
+beforeEach(() => {
+  resetContainer()
+})
+
+describe('workflow with named', () => {
+  it('should work with named pattern', async () => {
+    interface Database {
+      connect: () => Promise<void>
+      close: () => Promise<void>
+    }
+
+    const databaseConnectSpy = vi.fn()
+    const databaseCloseSpy = vi.fn()
+
+    function createDatabase(params: { lifecycle?: Lifecycle }): Database {
+      const database: Database = { connect: databaseConnectSpy, close: databaseCloseSpy }
+      params.lifecycle?.appHooks.onStop(async () => await database.close())
+      return database
+    }
+
+    interface WebSocketServer {
+      start: () => Promise<void>
+      stop: () => Promise<void>
+    }
+
+    const webSocketServerStartSpy = vi.fn()
+    const webSocketServerStopSpy = vi.fn()
+
+    async function createWebSocketServer(params: { database: Database, lifecycle?: Lifecycle }): Promise<WebSocketServer> {
+      await params.database.connect()
+      const server: WebSocketServer = { start: webSocketServerStartSpy, stop: webSocketServerStopSpy }
+      params.lifecycle?.appHooks.onStop(async () => await server.stop())
+      return server
+    }
+
+    provide<{ lifecycle: Lifecycle }>('db', {
+      dependsOn: { lifecycle: 'lifecycle' },
+      build: async ({ dependsOn }) => createDatabase({ lifecycle: dependsOn.lifecycle }),
+    })
+
+    provide<{ database: Database, lifecycle: Lifecycle }>('ws', {
+      dependsOn: { database: 'db', lifecycle: 'lifecycle' },
+      build: async ({ dependsOn }) => createWebSocketServer({ database: dependsOn.database, lifecycle: dependsOn.lifecycle }),
+    })
+
+    invoke<{ webSocketServer: WebSocketServer }>({
+      dependsOn: { webSocketServer: 'ws' },
+      callback: async ({ webSocketServer }) => await webSocketServer.start(),
+    })
+
+    await start()
+    await stop()
+
+    // eslint-disable-next-line no-lone-blocks
+    {
+      expect(databaseConnectSpy).toHaveBeenCalledTimes(1)
+      expect(databaseCloseSpy).toHaveBeenCalledTimes(1)
+      expect(webSocketServerStartSpy).toHaveBeenCalledTimes(1)
+      expect(webSocketServerStopSpy).toHaveBeenCalledTimes(1)
+    }
+  })
+})
+
+describe('workflow with typed', () => {
+  it('should work with typed named pattern', async () => {
+    interface Database {
+      connect: () => Promise<void>
+      close: () => Promise<void>
+    }
+
+    const databaseConnectSpy = vi.fn()
+    const databaseCloseSpy = vi.fn()
+
+    function createDatabase(params: { lifecycle?: Lifecycle }): Database {
+      const database: Database = { connect: databaseConnectSpy, close: databaseCloseSpy }
+      params.lifecycle?.appHooks.onStop(async () => await database.close())
+      return database
+    }
+
+    interface WebSocketServer {
+      start: () => Promise<void>
+      stop: () => Promise<void>
+    }
+
+    const webSocketServerStartSpy = vi.fn()
+    const webSocketServerStopSpy = vi.fn()
+
+    async function createWebSocketServer(params: { database: Database, lifecycle?: Lifecycle }): Promise<WebSocketServer> {
+      await params.database.connect()
+      const server: WebSocketServer = { start: webSocketServerStartSpy, stop: webSocketServerStopSpy }
+      params.lifecycle?.appHooks.onStop(async () => await server.stop())
+      return server
+    }
+
+    const database = provide('db', {
+      dependsOn: { lifecycle },
+      build: async ({ dependsOn }) => createDatabase(dependsOn),
+    })
+
+    const webSocketServer = provide('ws', {
+      dependsOn: { database, lifecycle },
+      build: async ({ dependsOn }) => createWebSocketServer(dependsOn),
+    })
+
+    invoke({
+      dependsOn: { webSocketServer },
+      callback: async ({ webSocketServer }) => await webSocketServer.start(),
+    })
+
+    await start()
+    await stop()
+
+    // eslint-disable-next-line no-lone-blocks
+    {
+      expect(databaseConnectSpy).toHaveBeenCalledTimes(1)
+      expect(databaseCloseSpy).toHaveBeenCalledTimes(1)
+      expect(webSocketServerStartSpy).toHaveBeenCalledTimes(1)
+      expect(webSocketServerStopSpy).toHaveBeenCalledTimes(1)
+    }
+  })
+})
+
+describe('workflow with auto name', () => {
+  it('should work with auto name pattern', async () => {
+    interface Database {
+      connect: () => Promise<void>
+      close: () => Promise<void>
+    }
+
+    const databaseConnectSpy = vi.fn()
+    const databaseCloseSpy = vi.fn()
+
+    function createDatabase(params: { lifecycle?: Lifecycle }): Database {
+      const database: Database = { connect: databaseConnectSpy, close: databaseCloseSpy }
+      params.lifecycle?.appHooks.onStop(async () => await database.close())
+      return database
+    }
+
+    interface WebSocketServer {
+      start: () => Promise<void>
+      stop: () => Promise<void>
+    }
+
+    const webSocketServerStartSpy = vi.fn()
+    const webSocketServerStopSpy = vi.fn()
+
+    async function createWebSocketServer(params: { database: Database, lifecycle?: Lifecycle }): Promise<WebSocketServer> {
+      await params.database.connect()
+      const server: WebSocketServer = { start: webSocketServerStartSpy, stop: webSocketServerStopSpy }
+      params.lifecycle?.appHooks.onStop(async () => await server.stop())
+      return server
+    }
+
+    const database = provide({
+      dependsOn: { lifecycle },
+      build: async ({ dependsOn }) => createDatabase(dependsOn),
+    })
+
+    const webSocketServer = provide({
+      dependsOn: { database, lifecycle },
+      build: async ({ dependsOn }) => createWebSocketServer(dependsOn),
+    })
+
+    invoke({
+      dependsOn: { webSocketServer },
+      callback: async ({ webSocketServer }) => await webSocketServer.start(),
+    })
+
+    await start()
+    await stop()
+
+    // eslint-disable-next-line no-lone-blocks
+    {
+      expect(databaseConnectSpy).toHaveBeenCalledTimes(1)
+      expect(databaseCloseSpy).toHaveBeenCalledTimes(1)
+      expect(webSocketServerStartSpy).toHaveBeenCalledTimes(1)
+      expect(webSocketServerStopSpy).toHaveBeenCalledTimes(1)
+    }
+  })
+})

packages/injecta/src/global.ts

@@ -1,21 +1,33 @@
-import type { DependencyMap, InvokeOption, Logger, ProvideOption } from '.'
+import type { DependencyMap, InvokeOption, InvokeOptionWithKeys, Logger, ProvideOption, ProvideOptionWithKeys, ResolveDependencyDeclaration } from '.'
+import type { ProvidedKey } from './scoped'
 
 import { createContainer, provide as indexProvide, start as indexStart, stop as indexStop } from '.'
 
-const globalContainer = createContainer()
+let globalContainer = createContainer()
 
 export function setLogger(logger: Logger) {
   globalContainer.logger = logger
 }
 
-export function provide<D extends DependencyMap | undefined, T = any>(
-  name: string,
-  option: ProvideOption<T, D>,
-): void {
-  indexProvide(globalContainer, name, option)
+export function resetContainer() {
+  globalContainer = createContainer()
 }
 
-export function invoke<D extends DependencyMap>(option: InvokeOption<D>): void {
+export function provide<T, Key extends string, Deps extends Record<string, string | ProvidedKey<any, any, any>>>(name: Key, option: ProvideOptionWithKeys<T, Deps>,): ProvidedKey<Key, T, ResolveDependencyDeclaration<Deps>>
+export function provide<D extends DependencyMap | undefined, T = any, Key extends string = string>(name: Key, option: ProvideOption<T, D>,): ProvidedKey<Key, T, D>
+export function provide<T, Key extends string, Deps extends Record<string, string | ProvidedKey<any, any, any>>>(option: ProvideOptionWithKeys<T, Deps>,): ProvidedKey<Key, T, ResolveDependencyDeclaration<Deps>>
+export function provide<D extends DependencyMap | undefined, T = any, Key extends string = string>(option: ProvideOption<T, D>,): ProvidedKey<Key, T, D>
+export function provide<D extends DependencyMap | undefined, T = any, Key extends string = string>(nameOrOption: Key | ProvideOption<T, D> | ProvideOptionWithKeys<T, any>, option?: ProvideOption<T, D> | ProvideOptionWithKeys<T, any>): ProvidedKey<Key, T, D> {
+  if (option != null && typeof option === 'function') {
+    return indexProvide(globalContainer, nameOrOption as any, { build: option, autoNameStackIndex: 2 } as any)
+  }
+
+  return indexProvide(globalContainer, nameOrOption as any, { ...option, autoNameStackIndex: 2 } as any)
+}
+
+export function invoke<Deps extends Record<string, string | ProvidedKey<any, any, any>>>(option: InvokeOptionWithKeys<Deps>): void
+export function invoke<D extends DependencyMap>(option: InvokeOption<D>): void
+export function invoke<D extends DependencyMap>(option: InvokeOption<D> | InvokeOptionWithKeys<any>): void {
   if (typeof option === 'function') {
     globalContainer.invocations.push({ callback: option } as any)
   }

packages/injecta/src/index.ts

@@ -19,6 +19,7 @@ export {
 export {
   createContainer,
   invoke,
+  lifecycle,
   provide,
   start,
   stop,
@@ -30,9 +31,15 @@ export type {
   InvokeOption,
   InvokeOptionFunc,
   InvokeOptionObject,
+  InvokeOptionObjectWithKeys,
+  InvokeOptionWithKeys,
+  ProvidedKey,
   ProvideOption,
   ProvideOptionFunc,
   ProvideOptionObject,
+  ProvideOptionObjectWithKeys,
+  ProvideOptionWithKeys,
+  ResolveDependencyDeclaration,
 } from './scoped'
 
 export const injecta = {

packages/injecta/src/logger.ts

@@ -1,4 +1,4 @@
-import { useLogg } from '@guiiai/logg'
+import type { Logg as LoggLogger } from '@guiiai/logg'
 
 import { name } from '../package.json'
 
@@ -80,9 +80,7 @@ export function createDefaultLogger(): Logger {
   }
 }
 
-export function createLoggLogger(): Logger {
-  const logg = useLogg(name).useGlobalConfig()
-
+export function createLoggLogger(logg: LoggLogger): Logger {
   return {
     provide: (name: string, dependencies: string[]) => {
       const depsStr = dependencies.length > 0 ? ` (depends on: ${dependencies.join(', ')})` : ''