@api-client/core 0.19.9 → 0.19.10

package/tests/unit/modeling/exposed_entity_actions.spec.ts

@@ -2,13 +2,19 @@ import { test } from '@japa/runner'
 import {
   ApiModel,
   CreateAction,
+  type CreateActionSchema,
   DataDomain,
   DeleteAction,
+  type DeleteActionSchema,
   DomainEntity,
   ListAction,
+  type ListActionSchema,
   ReadAction,
+  type ReadActionSchema,
   SearchAction,
+  type SearchActionSchema,
   UpdateAction,
+  type UpdateActionSchema,
 } from '../../../src/modeling/index.js'
 import { ExposedEntityKind } from '../../../src/models/kinds.js'
 import { nanoid } from '../../../src/nanoid.js'
@@ -25,7 +31,12 @@ test.group('ExposedEntity::actions', (group) => {
   })
 
   test('restores a list acton', ({ assert }) => {
-    const action = new ListAction()
+    const action: ListActionSchema = {
+      kind: 'list',
+      pagination: { kind: '' },
+      sortableFields: [],
+      filterableFields: [],
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -37,21 +48,23 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[0]!.actions[0]
     assert.ok(restoredAction, 'Action should be restored')
     assert.equal(restoredAction.kind, 'list', 'Action kind should be list')
     assert.instanceOf(restoredAction, ListAction, 'Action should be an instance of ListAction')
   }).tags(['@modeling', '@action', '@restoring'])
 
   test('restores a create acton', ({ assert }) => {
-    const action = new CreateAction()
+    const action: CreateActionSchema = {
+      kind: 'create',
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -63,21 +76,23 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[0]!.actions[0]
     assert.ok(restoredAction, 'Action should be restored')
     assert.equal(restoredAction.kind, 'create', 'Action kind should be create')
     assert.instanceOf(restoredAction, CreateAction, 'Action should be an instance of CreateAction')
   }).tags(['@modeling', '@action', '@restoring'])
 
   test('restores a read acton', ({ assert }) => {
-    const action = new ReadAction()
+    const action: ReadActionSchema = {
+      kind: 'read',
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -89,21 +104,24 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[0]!.actions[0]
     assert.ok(restoredAction, 'Action should be restored')
     assert.equal(restoredAction.kind, 'read', 'Action kind should be read')
     assert.instanceOf(restoredAction, ReadAction, 'Action should be an instance of ReadAction')
   }).tags(['@modeling', '@action', '@restoring'])
 
   test('restores a update acton', ({ assert }) => {
-    const action = new UpdateAction()
+    const action: UpdateActionSchema = {
+      kind: 'update',
+      allowedMethods: [],
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -115,21 +133,23 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[0]!.actions[0]
     assert.ok(restoredAction, 'Action should be restored')
     assert.equal(restoredAction.kind, 'update', 'Action kind should be update')
     assert.instanceOf(restoredAction, UpdateAction, 'Action should be an instance of UpdateAction')
   }).tags(['@modeling', '@action', '@restoring'])
 
   test('restores a delete acton', ({ assert }) => {
-    const action = new DeleteAction()
+    const action: DeleteActionSchema = {
+      kind: 'delete',
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -141,21 +161,24 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[0]!.actions[0]
     assert.ok(restoredAction, 'Action should be restored')
     assert.equal(restoredAction.kind, 'delete', 'Action kind should be delete')
     assert.instanceOf(restoredAction, DeleteAction, 'Action should be an instance of DeleteAction')
   }).tags(['@modeling', '@action', '@restoring'])
 
   test('restores a search acton', ({ assert }) => {
-    const action = new SearchAction()
+    const action: SearchActionSchema = {
+      kind: 'search',
+      fields: [],
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -167,14 +190,14 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[0]!.actions[0]
     assert.ok(restoredAction, 'Action should be restored')
     assert.equal(restoredAction.kind, 'search', 'Action kind should be search')
     assert.instanceOf(restoredAction, SearchAction, 'Action should be an instance of SearchAction')

package/tests/unit/modeling/exposed_entity_setter_validation.spec.ts

@@ -84,7 +84,7 @@ test.group('ExposedEntity Path Setter Validation', () => {
 
     // expose A -> B
     const rootExp = model.exposeEntity({ key: eA.key }, { followAssociations: true })
-    const nestedExp = model.exposes.find((e) => !e.isRoot)
+    const nestedExp = Array.from(model.exposes.values()).find((e) => !e.isRoot)
 
     assert.isDefined(nestedExp)
     // Assuming root entity has collection path /as

package/tests/unit/modeling/rules/restoring_rules.spec.ts

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { ApiModel, DataDomain, DomainEntity, ListAction } from '../../../../src/modeling/index.js'
+import { ApiModel, DataDomain, DomainEntity, type ListActionSchema } from '../../../../src/modeling/index.js'
 import {
   AllowAuthenticatedAccessRule,
   AllowPublicAccessRule,
@@ -71,7 +71,7 @@ test.group('restoring actions', (group) => {
       domain
     )
 
-    const ex = model.exposes[0]!
+    const ex = Array.from(model.exposes.values())[0]!
     assert.lengthOf(ex.accessRule!, 6)
     assert.instanceOf(ex.accessRule![0], AllowAuthenticatedAccessRule)
     assert.instanceOf(ex.accessRule![1], AllowPublicAccessRule)
@@ -88,9 +88,13 @@ test.group('restoring actions', (group) => {
     const r4 = new MatchResourceOwnerAccessRule()
     const r5 = new MatchUserPropertyAccessRule()
     const r6 = new MatchUserRoleAccessRule()
-    const action = new ListAction({
+    const action: ListActionSchema = {
+      kind: 'list',
+      pagination: { kind: '' },
+      sortableFields: [],
+      filterableFields: [],
       accessRule: [r1.toJSON(), r2.toJSON(), r3.toJSON(), r4.toJSON(), r5.toJSON(), r6.toJSON()],
-    }).toJSON()
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -109,7 +113,7 @@ test.group('restoring actions', (group) => {
       domain
     )
 
-    const ex = model.exposes[0]!.actions[0]!
+    const ex = Array.from(model.exposes.values())[0]!.actions[0]!
     assert.lengthOf(ex.accessRule!, 6)
     assert.instanceOf(ex.accessRule![0], AllowAuthenticatedAccessRule)
     assert.instanceOf(ex.accessRule![1], AllowPublicAccessRule)

package/tests/unit/modeling/validation/api_model_rules.spec.ts

@@ -0,0 +1,324 @@
+import { test } from '@japa/runner'
+import { ApiModel } from '../../../../src/modeling/ApiModel.js'
+import { DataDomain } from '../../../../src/modeling/DataDomain.js'
+
+import {
+  validateApiModelInfo,
+  validateApiModelDependency,
+  validateApiModelSecurity,
+  validateApiModelMetadata,
+  validateExposedEntity,
+  validateAction,
+  validateApiModel,
+} from '../../../../src/modeling/validation/api_model_rules.js'
+import { ExposedEntity } from '../../../../src/modeling/ExposedEntity.js'
+import { ListAction } from '../../../../src/modeling/actions/ListAction.js'
+import { DeleteAction } from '../../../../src/modeling/actions/DeleteAction.js'
+import { ReadAction } from '../../../../src/modeling/actions/ReadAction.js'
+import { SearchAction } from '../../../../src/modeling/actions/SearchAction.js'
+import { UpdateAction } from '../../../../src/modeling/actions/UpdateAction.js'
+import { RolesBasedAccessControl, UsernamePasswordConfiguration } from '../../../../src/modeling/types.js'
+import { SemanticType } from '../../../../src/modeling/Semantics.js'
+
+test.group('ApiModel Validation', () => {
+  test('validateApiModelInfo - success', ({ assert }) => {
+    const model = new ApiModel({
+      info: { name: 'Valid API', description: 'A test definition' },
+    })
+    const issues = validateApiModelInfo(model)
+    assert.isEmpty(issues)
+  })
+
+  test('validateApiModelInfo - missing required', ({ assert }) => {
+    const model = new ApiModel({
+      info: { name: '' },
+    })
+    const issues = validateApiModelInfo(model)
+    // Expect missing name and missing description
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_NAME'))
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_DESCRIPTION' && i.severity === 'warning'))
+  })
+
+  test('validateApiModelDependency - missing domain', ({ assert }) => {
+    const model = new ApiModel()
+    const issues = validateApiModelDependency(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_DOMAIN'))
+  })
+
+  test('validateApiModelDependency - valid domain', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = new ApiModel({}, domain)
+    const issues = validateApiModelDependency(model)
+    assert.isEmpty(issues)
+  })
+
+  test('validateApiModelSecurity - success', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass', semantics: [{ id: SemanticType.Password }] })
+    userEntity.addProperty({ key: 'role', semantics: [{ id: SemanticType.UserRole }] })
+    userEntity.addProperty({ key: 'name', semantics: [{ id: SemanticType.Username }] })
+
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: {
+          secret: 'super-secret',
+          properties: ['id', 'role'],
+          cookie: {
+            enabled: true,
+            kind: 'cookie',
+            lifetime: '7d',
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            name: 'as',
+          },
+        },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isEmpty(issues)
+  })
+
+  test('validateApiModelSecurity - missing session properties', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: {
+          secret: 'super-secret',
+          properties: [],
+          cookie: {
+            enabled: true,
+            kind: 'cookie',
+            lifetime: '7d',
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            name: 'as',
+          },
+        },
+        user: { key: 'nonexistent', domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_SESSION_PROPERTIES'))
+    assert.isTrue(issues.some((i) => i.code === 'API_INVALID_USER_ENTITY'))
+  })
+
+  test('validateApiModelSecurity - missing password semantic', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass' }) // missing password semantic
+    userEntity.addProperty({ key: 'role', semantics: [{ id: SemanticType.UserRole }] })
+    userEntity.addProperty({ key: 'name', semantics: [{ id: SemanticType.Username }] })
+
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: { secret: 'secret', properties: [] },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_PASSWORD_SEMANTIC'))
+  })
+
+  test('validateApiModelSecurity - missing username semantic', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass', semantics: [{ id: SemanticType.Password }] })
+    userEntity.addProperty({ key: 'role', semantics: [{ id: SemanticType.UserRole }] })
+    userEntity.addProperty({ key: 'name' }) // no username semantic
+
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: { secret: 'secret', properties: [] },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_USERNAME_SEMANTIC'))
+  })
+
+  test('validateApiModelSecurity - missing role semantic', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass', semantics: [{ id: SemanticType.Password }] })
+    userEntity.addProperty({ key: 'role' }) // missing role semantic
+    userEntity.addProperty({ key: 'name', semantics: [{ id: SemanticType.Username }] })
+
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: { secret: 'secret', properties: [] },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_ROLE_SEMANTIC'))
+  })
+
+  test('validateApiModelMetadata - contact warnings', ({ assert }) => {
+    const model = new ApiModel()
+    const issues = validateApiModelMetadata(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_CONTACT' && i.severity === 'info'))
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_LICENSE' && i.severity === 'info'))
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_TOS' && i.severity === 'info'))
+  })
+
+  test('validateApiModelMetadata - invalid urls and emails', ({ assert }) => {
+    const model = new ApiModel({
+      contact: { email: 'invalid-email', url: 'invalid-url' },
+      license: { name: 'MIT', url: 'invalid-url' },
+    })
+    const issues = validateApiModelMetadata(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_INVALID_CONTACT_EMAIL'))
+    assert.isTrue(issues.some((i) => i.code === 'API_INVALID_CONTACT_URL'))
+    assert.isTrue(issues.some((i) => i.code === 'API_INVALID_LICENSE_URL'))
+  })
+
+  test('validateExposedEntity - missing actions', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = new ApiModel({}, domain)
+    const exposure = new ExposedEntity(model, {
+      entity: { key: 'fake' },
+      collectionPath: '/items',
+      resourcePath: '/items/{id}',
+      hasCollection: true,
+    })
+    exposure.actions = [] // Override default behaviour
+
+    // override collectionPath/resourcePath defaults since exposure sets it if missing
+    exposure.collectionPath = '/items'
+    exposure.resourcePath = '/items/{id}'
+
+    const issues = validateExposedEntity(exposure, model)
+    assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_MISSING_ACTIONS'))
+    assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_INVALID_ENTITY_REF')) // because fake entity doesn't exist
+  })
+
+  test('validateExposedEntity - path integrity (has collection)', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = new ApiModel({}, domain)
+    const exposure = new ExposedEntity(model, {
+      entity: { key: 'fake' },
+      hasCollection: true,
+    })
+    exposure.collectionPath = 'invalid_no_slash'
+    exposure.resourcePath = '/invalid_no_slash_resource'
+    exposure.actions = [new ReadAction(exposure)]
+    const issues = validateExposedEntity(exposure, model)
+    assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_INVALID_COLLECTION_PATH'))
+    assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_INVALID_RESOURCE_PATH_FORMAT'))
+  })
+
+  test('validateAction - List needs pagination', ({ assert }) => {
+    const model = new ApiModel()
+    const exposure = new ExposedEntity(model, { entity: { key: '1' } })
+    const action = new ListAction(exposure)
+    // @ts-expect-error testing undefined pagination
+    action.pagination = undefined
+
+    const issues = validateAction(action, exposure, model.key)
+    assert.isTrue(issues.some((i) => i.code === 'ACTION_LIST_MISSING_PAGINATION'))
+  })
+
+  test('validateAction - Search needs fields', ({ assert }) => {
+    const model = new ApiModel()
+    const exposure = new ExposedEntity(model, { entity: { key: '1' } })
+    const action = new SearchAction(exposure)
+    action.fields = []
+
+    const issues = validateAction(action, exposure, model.key)
+    assert.isTrue(issues.some((i) => i.code === 'ACTION_SEARCH_MISSING_FIELDS'))
+  })
+
+  test('validateAction - Delete needs strategy', ({ assert }) => {
+    const model = new ApiModel()
+    const exposure = new ExposedEntity(model, { entity: { key: '1' } })
+    const action = new DeleteAction(exposure)
+    // @ts-expect-error testing undefined strategy
+    action.strategy = undefined
+
+    const issues = validateAction(action, exposure, model.key)
+    assert.isTrue(issues.some((i) => i.code === 'ACTION_DELETE_MISSING_STRATEGY'))
+  })
+
+  test('validateAction - Update needs methods', ({ assert }) => {
+    const model = new ApiModel()
+    const exposure = new ExposedEntity(model, { entity: { key: '1' } })
+    const action = new UpdateAction(exposure)
+    action.allowedMethods = []
+
+    const issues = validateAction(action, exposure, model.key)
+    assert.isTrue(issues.some((i) => i.code === 'ACTION_UPDATE_MISSING_METHODS'))
+  })
+  test('validateApiModel - success aggregates without issues', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass', semantics: [{ id: SemanticType.Password }] })
+    userEntity.addProperty({ key: 'role', semantics: [{ id: SemanticType.UserRole }] })
+    userEntity.addProperty({ key: 'name', semantics: [{ id: SemanticType.Username }] })
+    const model = new ApiModel(
+      {
+        info: { name: 'Valid API', description: 'A test definition' },
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: {
+          secret: 'super-secret',
+          properties: ['id', 'role'],
+          cookie: {
+            enabled: true,
+            kind: 'cookie',
+            lifetime: '7d',
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            name: 'as',
+          },
+        },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+    const result = validateApiModel(model)
+    assert.isTrue(result.isValid)
+    assert.isEmpty(result.issues.filter((i) => i.severity === 'error'))
+  })
+
+  test('validateApiModel - fails on multiple errors', ({ assert }) => {
+    const model = new ApiModel({
+      info: { name: '' },
+    })
+    // Now it's missing name, missing domain, missing security context, missing contact.
+    const result = validateApiModel(model)
+    assert.isFalse(result.isValid)
+    assert.isTrue(result.issues.some((i) => i.code === 'API_MISSING_NAME'))
+    assert.isTrue(result.issues.some((i) => i.code === 'API_MISSING_DOMAIN'))
+    assert.isTrue(result.issues.some((i) => i.code === 'API_MISSING_AUTHENTICATION'))
+  })
+})

package/tsconfig.browser.json

@@ -30,5 +30,5 @@
     "incremental": true
   },
   "include": ["src/**/*", "test/**/*"],
-  "exclude": ["node_modules", "build", "coverage", ".tmp", ".wireit", "amf-models", "bin", "data", "docs", "scripts"],
+  "exclude": ["node_modules", "build", "coverage", ".tmp", "amf-models", "bin", "data", "docs", "scripts"],
 }

package/tsconfig.node.json

@@ -32,5 +32,5 @@
     "incremental": true
   },
   "include": ["src/**/*", "tests/**/*", "bin/test.ts"],
-  "exclude": ["node_modules", "build", "coverage", ".tmp", ".wireit", "amf-models", "data", "docs", "scripts"],
+  "exclude": ["node_modules", "build", "coverage", ".tmp", "amf-models", "data", "docs", "scripts"],
 }

package/bin/test-web.ts

@@ -1,6 +0,0 @@
-import { startTestRunner } from '@web/test-runner'
-
-await startTestRunner({
-  autoExitProcess: true,
-  readCliArgs: true,
-})