feat(config): addon queries feature

now you can use queries instead of import and instantiate classes

Author: dangreen

packages/config/.eslintrc.json

@@ -9,6 +9,9 @@
     "project": ["./tsconfig.json"]
   },
   "rules": {
-    "@typescript-eslint/naming-convention": "off"
+    "@typescript-eslint/naming-convention": "off",
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-unsafe-call": "off",
+    "@typescript-eslint/no-unsafe-return": "off"
   }
 }

packages/config/README.md

@@ -57,3 +57,44 @@ await load() // Returns config object or null
 await load({ config: true }) // Returns config object or throws an error if config is not found
 await load({ [propertyName]: true }) // Returns config object with desired property or null or throws an error if property is not set in config
 ```
+
+Also loader has a feature to load and instantiate addon's classes. For example, if you have a config like this:
+
+```js
+export const project = [
+  '@simple-release/pnpm#PnpmWorkspacesProject',
+  {
+    mode: 'independent'
+  }
+]
+```
+
+You can load it like this:
+
+```js
+import { load } from '@simple-release/config'
+
+const config = await load()
+
+config.project // Will be an instance of PnpmWorkspacesProject
+```
+
+You can pass your own loader and use queries with version:
+
+```js
+export const project = [
+  '@simple-release/[email protected]#PnpmWorkspacesProject',
+  {
+    mode: 'independent'
+  }
+]
+```
+
+```js
+import { load } from '@simple-release/config'
+
+const config = await load({}, async (name, version) => {
+  await install(name, version) // For example you can implement lazy install here
+  return import(name)
+})
+```

packages/config/package.json

@@ -47,8 +47,9 @@
     "postpublish": "pnpm clear:package",
     "build": "tsc -p tsconfig.build.json",
     "lint": "eslint --parser-options tsconfigRootDir:. '**/*.{js,ts}'",
+    "test:unit": "vitest run --coverage",
     "test:types": "tsc --noEmit",
-    "test": "run -p lint test:types"
+    "test": "run -p lint test:unit test:types"
   },
   "dependencies": {
     "@simple-release/core": "workspace:^",

packages/config/src/index.spec.ts

@@ -0,0 +1,100 @@
+import { join } from 'path'
+import {
+  vi,
+  describe,
+  it,
+  expect
+} from 'vitest'
+import { PackageJsonProject } from '@simple-release/core'
+import {
+  parseImportQuery,
+  loadClass
+} from './index.js'
+
+describe('config', () => {
+  describe('parseImportQuery', () => {
+    it('should parse a simple import query', () => {
+      expect(
+        parseImportQuery('path/to/module')
+      ).toEqual({
+        path: 'path/to/module'
+      })
+    })
+
+    it('should parse an import query with version', () => {
+      expect(
+        parseImportQuery('path/to/[email protected]')
+      ).toEqual({
+        path: 'path/to/module',
+        version: '1.0.0'
+      })
+    })
+
+    it('should parse an import query with symbol', () => {
+      expect(
+        parseImportQuery('path/to/module#MyClass')
+      ).toEqual({
+        path: 'path/to/module',
+        symbol: 'MyClass'
+      })
+    })
+
+    it('should parse an import query with version and symbol', () => {
+      expect(
+        parseImportQuery('path/to/[email protected]#MyClass')
+      ).toEqual({
+        path: 'path/to/module',
+        version: '1.0.0',
+        symbol: 'MyClass'
+      })
+    })
+
+    it('should parse an import query with scoped package', () => {
+      expect(
+        parseImportQuery('@simple-release/core#PackageJsonProject')
+      ).toEqual({
+        path: '@simple-release/core',
+        symbol: 'PackageJsonProject'
+      })
+    })
+  })
+
+  describe('loadClass', () => {
+    it('should load a class from a module', async () => {
+      const project = await loadClass(
+        [
+          '@simple-release/core#PackageJsonProject',
+          {
+            path: join(__dirname, '..', 'package.json')
+          }
+        ],
+        {}
+      )
+
+      expect(project).toBeInstanceOf(PackageJsonProject)
+    })
+
+    it('should use custom loader', async () => {
+      const loader = vi.fn(() => Promise.resolve({
+        PackageJsonProject
+      }))
+      const project = await loadClass(
+        [
+          '@simple-release/[email protected]#PackageJsonProject',
+          {
+            path: join(__dirname, '..', 'package.json')
+          }
+        ],
+        {
+          config: 'yes'
+        } as any,
+        loader
+      )
+
+      expect(project).toBeInstanceOf(PackageJsonProject)
+      expect(loader).toHaveBeenCalledWith('@simple-release/core', '1.0.0', {
+        config: 'yes'
+      })
+    })
+  })
+})

packages/config/src/index.ts

@@ -10,7 +10,8 @@ import type {
 const VARIANTS = [
   '.simple-release.js',
   '.simple-release.mjs',
-  '.simple-release.cjs'
+  '.simple-release.cjs',
+  '.simple-release.json'
 ]
 
 export interface SimpleReleaseConfig<
@@ -46,6 +47,18 @@ type Result<
   ? ApplyConfigRequirement<R, C>
   : never
 
+interface ParsedImportQuery {
+  path: string
+  version?: string
+  symbol?: string
+}
+
+type Loader<T = Record<string, any>> = (
+  path: string,
+  version: string | undefined,
+  rawConfig: Record<string, any>
+) => Promise<T>
+
 function validate(target: Record<string, any>, rules: Record<string, any>) {
   for (const [rule, required] of Object.entries(rules)) {
     if (required && target[rule] === undefined) {
@@ -54,18 +67,101 @@ function validate(target: Record<string, any>, rules: Record<string, any>) {
   }
 }
 
+const IMPORT_QUERY_REGEX = /^(@?[^@#]*)(@[^#]+)?(#.*)?$/
+
+export function parseImportQuery(
+  importPath: string
+): ParsedImportQuery {
+  const match = importPath.match(IMPORT_QUERY_REGEX)
+
+  if (!match) {
+    return {
+      path: importPath
+    }
+  }
+
+  const [
+    ,
+    path,
+    version,
+    symbol
+  ] = match
+
+  return {
+    path,
+    version: version?.slice(1),
+    symbol: symbol?.slice(1)
+  }
+}
+
+export async function loadClass<T, C extends SimpleReleaseConfig>(
+  queryWithOptions: string | [string, Record<string, any>],
+  config: C,
+  loader: Loader = _ => import(_)
+) {
+  const [query, options] = Array.isArray(queryWithOptions)
+    ? queryWithOptions
+    : [queryWithOptions]
+  const {
+    path,
+    version,
+    symbol
+  } = parseImportQuery(query)
+  const module = await loader(path, version, config)
+  const inst = new module[symbol || 'default'](options) as T
+
+  return inst
+}
+
+export function isQuery(value: unknown): value is string | [string, Record<string, any>] {
+  return typeof value === 'string' || (
+    Array.isArray(value)
+    && value.length === 2
+    && typeof value[0] === 'string'
+    && value[1] && typeof value[1] === 'object'
+  )
+}
+
+export function getQuery(queryWithOptions: unknown): string | null {
+  return isQuery(queryWithOptions)
+    ? typeof queryWithOptions === 'string'
+      ? queryWithOptions
+      : queryWithOptions[0]
+    : null
+}
+
+async function loadAndSetIfQuery(
+  config: SimpleReleaseConfig,
+  key: keyof SimpleReleaseConfig,
+  loader?: Loader
+) {
+  const value = config[key]
+
+  if (value && isQuery(value)) {
+    // eslint-disable-next-line require-atomic-updates
+    config[key] = await loadClass(value, config, loader)
+  }
+}
+
 /**
  * Load simple-release config.
  * @param requirements
+ * @param loader
  * @returns simple-release config
  */
 export async function load<
   P extends Project = Project,
   G extends GitRepositoryHosting = GitRepositoryHosting,
   R extends SimpleReleaseConfigRequirements = SimpleReleaseConfigRequirements
->(requirements?: R): Promise<Result<P, G, R>>
-
-export async function load(requirements: Record<string, any> = {}) {
+>(
+  requirements?: R,
+  loader?: Loader
+): Promise<Result<P, G, R>>
+
+export async function load(
+  requirements: Record<string, any> = {},
+  loader?: Loader
+) {
   const {
     config: configRequired,
     ...reqs
@@ -81,6 +177,9 @@ export async function load(requirements: Record<string, any> = {}) {
 
         validate(config, reqs)
 
+        await loadAndSetIfQuery(config, 'project', loader)
+        await loadAndSetIfQuery(config, 'hosting', loader)
+
         return config
       } catch (err) {
         if (configRequired) {