@api-client/core 0.20.5 → 0.20.7

package/tests/unit/modeling/generators/RuntimeModelGenerator.spec.ts

@@ -0,0 +1,192 @@
+import { test } from '@japa/runner'
+import { ApiModel } from '../../../../src/modeling/ApiModel.js'
+import { ExposedEntityKind } from '../../../../src/models/index.js'
+import { RuntimeModelGenerator } from '../../../../src/modeling/generators/RuntimeModelGenerator.js'
+import { ApiModelKind } from '../../../../src/models/index.js'
+import type { UpdateActionSchema } from '../../../../src/modeling/actions/index.js'
+
+test.group('RuntimeModelGenerator', () => {
+  test('generates routes from an ApiModel instance', async ({ assert }) => {
+    const apiModel = new ApiModel({
+      key: 'test-api',
+      exposes: [
+        {
+          key: 'users',
+          kind: ExposedEntityKind,
+          entity: { key: 'user' },
+          resourcePath: '/users/{id}',
+          collectionPath: '/users',
+          hasCollection: true,
+          isRoot: true,
+          actions: [
+            { kind: 'list' },
+            { kind: 'create' },
+            { kind: 'search' },
+            { kind: 'read' },
+            { kind: 'update', allowedMethods: ['PUT', 'PATCH'] } as UpdateActionSchema,
+            { kind: 'delete' },
+          ],
+        },
+      ],
+    })
+
+    const generator = new RuntimeModelGenerator(apiModel)
+    const result = await generator.generate()
+
+    assert.equal(result.key, 'test-api')
+    assert.deepEqual(result.routingMap['GET']![0], {
+      path: '/users',
+      lookup: { exposedEntityKey: 'users', actionKind: 'list' },
+    })
+
+    assert.deepEqual(result.routingMap['GET']![1], {
+      path: '/users/{id}',
+      lookup: { exposedEntityKey: 'users', actionKind: 'read' },
+    })
+
+    assert.deepEqual(result.routingMap['POST']![0], {
+      path: '/users',
+      lookup: { exposedEntityKey: 'users', actionKind: 'create' },
+    })
+
+    assert.deepEqual(result.routingMap['POST']![1], {
+      path: '/users/search',
+      lookup: { exposedEntityKey: 'users', actionKind: 'search' },
+    })
+
+    assert.deepEqual(result.routingMap['PUT']![0], {
+      path: '/users/{id}',
+      lookup: { exposedEntityKey: 'users', actionKind: 'update' },
+    })
+
+    assert.deepEqual(result.routingMap['PATCH']![0], {
+      path: '/users/{id}',
+      lookup: { exposedEntityKey: 'users', actionKind: 'update' },
+    })
+
+    assert.deepEqual(result.routingMap['DELETE']![0], {
+      path: '/users/{id}',
+      lookup: { exposedEntityKey: 'users', actionKind: 'delete' },
+    })
+  }).tags(['@modeling', '@generator'])
+
+  test('generates routes from an ApiModelSchema object', async ({ assert }) => {
+    const schema = {
+      kind: ApiModelKind,
+      key: 'test-api-schema',
+      exposes: [
+        {
+          key: 'posts',
+          kind: ExposedEntityKind,
+          entity: { key: 'post' },
+          resourcePath: '/posts/{id}',
+          collectionPath: '/posts',
+          hasCollection: true,
+          isRoot: true,
+          actions: [{ kind: 'list' }],
+        },
+      ],
+    }
+
+    const generator = new RuntimeModelGenerator(schema as any)
+    const result = await generator.generate()
+
+    assert.equal(result.key, 'test-api-schema')
+    assert.lengthOf(result.routingMap['GET'] || [], 1)
+    assert.deepEqual(result.routingMap['GET']![0], {
+      path: '/posts',
+      lookup: { exposedEntityKey: 'posts', actionKind: 'list' },
+    })
+  }).tags(['@modeling', '@generator'])
+
+  test('handles entities without collection paths safely', async ({ assert }) => {
+    const apiModel = new ApiModel({
+      key: 'test-api',
+      exposes: [
+        {
+          key: 'singleton',
+          kind: ExposedEntityKind,
+          entity: { key: 'config' },
+          resourcePath: '/singleton',
+          hasCollection: false,
+          isRoot: true,
+          actions: [{ kind: 'list' }, { kind: 'create' }, { kind: 'search' }],
+        },
+      ],
+    })
+
+    const generator = new RuntimeModelGenerator(apiModel)
+    const result = await generator.generate()
+
+    // Without a collection path, list, create, search should be ignored.
+    assert.deepEqual(result.routingMap, {})
+  }).tags(['@modeling', '@generator'])
+
+  test('generates routes for nested entities (sub-endpoints)', async ({ assert }) => {
+    const apiModel = new ApiModel({
+      key: 'test-api',
+      exposes: [
+        {
+          key: 'users',
+          kind: ExposedEntityKind,
+          entity: { key: 'user' },
+          resourcePath: '/users/{userId}',
+          collectionPath: '/users',
+          hasCollection: true,
+          isRoot: true,
+          actions: [{ kind: 'read' }],
+        },
+        {
+          key: 'user-posts',
+          kind: ExposedEntityKind,
+          entity: { key: 'post' },
+          resourcePath: '/posts/{postId}',
+          collectionPath: '/posts',
+          hasCollection: true,
+          isRoot: false,
+          parent: { key: 'users', association: { key: 'user-posts' } },
+          actions: [
+            { kind: 'list' },
+            { kind: 'read' },
+            { kind: 'create' },
+            { kind: 'update', allowedMethods: ['PATCH'] } as UpdateActionSchema,
+            { kind: 'delete' },
+          ],
+        },
+      ],
+    })
+
+    const generator = new RuntimeModelGenerator(apiModel)
+    const result = await generator.generate()
+
+    assert.deepInclude(result.routingMap['GET']!, {
+      path: '/users/{userId}',
+      lookup: { exposedEntityKey: 'users', actionKind: 'read' },
+    })
+
+    assert.deepInclude(result.routingMap['GET']!, {
+      path: '/users/{userId}/posts',
+      lookup: { exposedEntityKey: 'user-posts', actionKind: 'list' },
+    })
+
+    assert.deepInclude(result.routingMap['GET']!, {
+      path: '/users/{userId}/posts/{postId}',
+      lookup: { exposedEntityKey: 'user-posts', actionKind: 'read' },
+    })
+
+    assert.deepInclude(result.routingMap['POST']!, {
+      path: '/users/{userId}/posts',
+      lookup: { exposedEntityKey: 'user-posts', actionKind: 'create' },
+    })
+
+    assert.deepInclude(result.routingMap['PATCH']!, {
+      path: '/users/{userId}/posts/{postId}',
+      lookup: { exposedEntityKey: 'user-posts', actionKind: 'update' },
+    })
+
+    assert.deepInclude(result.routingMap['DELETE']!, {
+      path: '/users/{userId}/posts/{postId}',
+      lookup: { exposedEntityKey: 'user-posts', actionKind: 'delete' },
+    })
+  }).tags(['@modeling', '@generator'])
+})

package/tests/unit/modeling/helpers/endpointHelpers.spec.ts

@@ -2,9 +2,16 @@ import { test } from '@japa/runner'
 import * as helpers from '../../../../src/modeling/helpers/endpointHelpers.js'
 
 test.group('endpointHelpers', () => {
-  test('paramNameFor extracts last key', ({ assert }) => {
+  test('paramNameFor handles various arbitrary strings', ({ assert }) => {
     assert.equal(helpers.paramNameFor('product'), 'productId')
-    assert.equal(helpers.paramNameFor('domain:product'), 'productId')
-    assert.equal(helpers.paramNameFor('a:b:c'), 'cId')
+    assert.equal(helpers.paramNameFor('user_post'), 'userPostId')
+    assert.equal(helpers.paramNameFor('UserPost'), 'userPostId')
+    assert.equal(helpers.paramNameFor('USER_POST'), 'userPostId')
+    assert.equal(helpers.paramNameFor('user-post'), 'userPostId')
+    assert.equal(helpers.paramNameFor('User Post! '), 'userPostId')
+    assert.equal(helpers.paramNameFor('123item'), '_123itemId')
+    assert.equal(helpers.paramNameFor('XMLHttp'), 'xmlHttpId')
+    assert.throws(() => helpers.paramNameFor('!@#$'), 'Cannot generate a valid parameter name from "!@#$".')
+    assert.throws(() => helpers.paramNameFor(''), 'Cannot generate parameter name from an empty string.')
   })
 })

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

@@ -249,6 +249,41 @@ test.group('ApiModel Validation', () => {
     assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_INVALID_RESOURCE_PATH_FORMAT'))
   })
 
+  test('validateExposedEntity - catches duplicate path parameters in branch', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = new ApiModel({}, domain)
+
+    // Parent exposure with parameter {id}
+    const parentExposure = new ExposedEntity(model, {
+      key: 'parent',
+      entity: { key: 'fakeParent' },
+      hasCollection: true,
+      collectionPath: '/parents',
+      resourcePath: '/parents/{id}',
+      isRoot: true,
+      actions: [],
+    })
+
+    // Child exposure with the same parameter {id}
+    const childExposure = new ExposedEntity(model, {
+      key: 'child',
+      entity: { key: 'fakeChild' },
+      hasCollection: true,
+      collectionPath: '/children',
+      resourcePath: '/children/{id}',
+      parent: { key: 'parent', association: { key: 'toChildren' } },
+      actions: [],
+    })
+
+    model.exposes = new Map([
+      [parentExposure.key, parentExposure],
+      [childExposure.key, childExposure],
+    ])
+
+    const issues = validateExposedEntity(childExposure, model)
+    assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_DUPLICATE_PATH_PARAMETER'))
+  })
+
   test('validateExposedEntity - List needs pagination contract', ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const model = new ApiModel({}, domain)