@api-client/core 0.19.31 → 0.19.33

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.19.31",
+  "version": "0.19.33",
   "license": "UNLICENSED",
   "exports": {
     "./browser.js": {

package/src/data/DataExtractor.ts

@@ -9,7 +9,7 @@ import { XmlReader } from './XmlReader.js'
 import { UrlEncodedReader } from './UrlEncodedReader.js'
 import { CookieParser } from '../cookies/CookieParser.js'
 
-type DataInput =
+export type DataInput =
   | HttpRequest
   | SentRequest
   | IHttpRequest

package/src/mocking/lib/User.ts

@@ -1,6 +1,7 @@
 import { faker } from '@faker-js/faker'
 import { nanoid } from '../../nanoid.js'
-import { UserSchema, Kind as UserKind } from '../../models/store/User.js'
+import { UserSchema } from '../../models/store/User.js'
+import { UserKind } from '../../models/kinds.js'
 
 export interface UserInitSchema {
   noEmail?: boolean

package/src/modeling/ApiModel.ts

@@ -6,9 +6,7 @@ import type {
   AuthenticationStrategy,
   AuthorizationStrategy,
   ExposedEntitySchema,
-  RolesBasedAccessControl,
   SessionConfiguration,
-  UsernamePasswordConfiguration,
   ExposeOptions,
   OffsetPaginationStrategy,
   CursorPaginationStrategy,
@@ -668,14 +666,6 @@ export class ApiModel extends DependentModel {
     if (this.session) {
       this.session.properties = []
     }
-    if (this.authentication && this.authentication.strategy === 'UsernamePassword') {
-      const typed = this.authentication as UsernamePasswordConfiguration
-      typed.passwordKey = undefined
-    }
-    if (this.authorization && this.authorization.strategy == 'RBAC') {
-      const typed = this.authorization as RolesBasedAccessControl
-      typed.roleKey = ''
-    }
   }
 
   /**

package/src/modeling/RuntimeApiModel.ts

@@ -4,6 +4,9 @@ import type { DataDomainSchema } from './DataDomain.js'
 import type { ActionKind } from './actions/index.js'
 import type { ExposedEntity } from './ExposedEntity.js'
 import type { Action } from './actions/Action.js'
+import { SemanticType } from './Semantics.js'
+import type { DomainEntity } from './DomainEntity.js'
+import type { DomainProperty } from './DomainProperty.js'
 
 /**
  * Identifies a specific exposed entity and its action kind.
@@ -55,12 +58,55 @@ export class RuntimeApiModel extends ApiModel {
    */
   #definitions = new WeakMap<RouteToken[], RouteDefinition>()
 
+  /**
+   * Cached references to commonly used entities for fast runtime lookup.
+   */
+  cachedEntities: {
+    user?: DomainEntity
+  } = {}
+
+  /**
+   * Cached references to commonly used properties for fast runtime lookup.
+   */
+  cachedProperties: {
+    username?: DomainProperty
+    password?: DomainProperty
+    role?: DomainProperty
+  } = {}
+
   constructor(schema: RuntimeApiModelSchema, domainSchema: DataDomainSchema) {
     super(schema, domainSchema)
 
     if (schema.routingMap) {
       this.#initializeRouter(schema.routingMap)
     }
+
+    this.#cacheEntitiesAndProperties()
+  }
+
+  #cacheEntitiesAndProperties() {
+    if (!this.user || !this.domain) {
+      return
+    }
+
+    const userEntity = this.domain.findEntity(this.user.key, this.user.domain)
+    if (!userEntity) {
+      return
+    }
+
+    this.cachedEntities.user = userEntity
+
+    for (const prop of userEntity.properties) {
+      if (prop.hasSemantic(SemanticType.Username)) {
+        this.cachedProperties.username = prop
+      }
+      if (prop.hasSemantic(SemanticType.Password)) {
+        this.cachedProperties.password = prop
+      }
+      if (prop.hasSemantic(SemanticType.UserRole)) {
+        this.cachedProperties.role = prop
+      }
+    }
   }
 
   #initializeRouter(routingMap: RoutingMap) {

package/src/modeling/ai/DataDomainDelta.ts

@@ -1,4 +1,4 @@
-import type { DataDomain } from '@api-client/core/modeling/DataDomain.js'
+import type { DataDomain } from '../DataDomain.js'
 import type {
   AiDataModelSchema,
   AiDomainAssociation,
@@ -10,16 +10,10 @@ import type {
   AiDomainPropertyDelta,
   AiDomainSemantic,
 } from './types.js'
-import type {
-  DomainAssociation,
-  DomainEntity,
-  DomainEntitySchema,
-  DomainModel,
-  DomainProperty,
-} from '@api-client/core/modeling/index.js'
-import { nanoid } from '@api-client/core/nanoid.js'
-import { type SemanticType, SemanticScope, DataSemantics } from '@api-client/core/modeling/Semantics.js'
-import { DomainEntityKind, DomainPropertyKind, DomainAssociationKind } from '@api-client/core/models/kinds.js'
+import type { DomainAssociation, DomainEntity, DomainEntitySchema, DomainModel, DomainProperty } from '../index.js'
+import { nanoid } from '../../nanoid.js'
+import { type SemanticType, SemanticScope, DataSemantics } from '../Semantics.js'
+import { DomainEntityKind, DomainPropertyKind, DomainAssociationKind } from '../../models/kinds.js'
 
 /**
  * Normalizes the delta by removing duplicates. For example, when the model

package/src/modeling/readme.md

@@ -187,8 +187,8 @@ apiModel.attachDataDomain(domain)
 
 // 4. Configure security
 apiModel.user = { key: userEntity.key }
-apiModel.authentication = { strategy: 'UsernamePassword', passwordKey: 'password' }
-apiModel.authorization = { strategy: 'RBAC', roleKey: 'role' }
+apiModel.authentication = { strategy: 'UsernamePassword' }
+apiModel.authorization = { strategy: 'RBAC' }
 apiModel.session = { 
   secret: 'your-secure-secret',
   properties: ['email', 'role'],

package/src/modeling/types.ts

@@ -393,14 +393,6 @@ export interface AuthorizationConfiguration {
 
 export interface RolesBasedAccessControl extends AuthorizationConfiguration {
   strategy: 'RBAC'
-  /**
-   * The property within the designated "User" entity that defines the user's role.
-   * This field is used in access rules to grant permissions.
-   *
-   * This property must be marked with the "Role" data semantic in the Data Modeler.
-   * It is required to publish the API.
-   */
-  roleKey: string
 }
 
 export type AuthorizationStrategy = RolesBasedAccessControl
@@ -424,13 +416,6 @@ export interface AuthenticationConfiguration {
  */
 export interface UsernamePasswordConfiguration extends AuthenticationConfiguration {
   strategy: 'UsernamePassword'
-  /**
-   * The specific property within the User entity that holds the password.
-   * This property must be marked with the "Password" data semantic in the Data Modeler.
-   *
-   * This property is required to publish the API.
-   */
-  passwordKey?: string
 }
 
 export type AuthenticationStrategy = UsernamePasswordConfiguration

package/src/modeling/validation/api_model_rules.ts

@@ -5,10 +5,10 @@ import { ListAction } from '../actions/ListAction.js'
 import { DeleteAction } from '../actions/DeleteAction.js'
 import { UpdateAction } from '../actions/UpdateAction.js'
 import { SearchAction } from '../actions/SearchAction.js'
-import type { RolesBasedAccessControl, UsernamePasswordConfiguration } from '../types.js'
 import type { ApiModelValidationItem, ApiModelValidationContext } from '../types.js'
 import { ApiModelKind, ExposedEntityKind } from '../../models/kinds.js'
 import { SemanticType } from '../Semantics.js'
+import { DomainProperty } from '../DomainProperty.js'
 
 /**
  * Creates a unique validation code.
@@ -127,35 +127,32 @@ export function validateApiModelSecurity(model: ApiModel): ApiModelValidationIte
       context: { ...context, property: 'authentication' },
     })
   } else if (model.authentication.strategy === 'UsernamePassword') {
-    const auth = model.authentication as UsernamePasswordConfiguration
-    if (!auth.passwordKey) {
-      issues.push({
-        code: createCode('API', 'MISSING_PASSWORD_KEY'),
-        message: 'Username & Password authentication requires a specific field for the password.',
-        suggestion:
-          'Select which field in your user profile should store the password. ' +
-          'The data domain model should have a password data semantic on that property.',
-        severity: 'error',
-        context: { ...context, property: 'authentication.passwordKey' },
-      })
-    } else if (userEntity) {
-      const passwordProp = Array.from(userEntity.properties).find((p) => p.key === auth.passwordKey)
-      if (passwordProp && !passwordProp.hasSemantic(SemanticType.Password)) {
+    if (userEntity) {
+      let passwordProp: DomainProperty | undefined
+      for (const prop of userEntity.properties) {
+        if (prop.hasSemantic(SemanticType.Password)) {
+          passwordProp = prop
+          break
+        }
+      }
+      if (!passwordProp) {
         issues.push({
           code: createCode('API', 'MISSING_PASSWORD_SEMANTIC'),
-          message: 'The selected password field is missing the Password data semantic.',
-          suggestion: 'Go to the Data Modeler and add the "Password" semantic to this property.',
+          message: 'The selected user model requires a property with the Password data semantic for authentication.',
+          suggestion: 'Go to the Data Modeler and add the "Password" semantic to the password property.',
           severity: 'error',
-          context: { ...context, property: 'authentication.passwordKey' },
+          context: { ...context, property: 'user' },
         })
       }
-    }
 
-    if (userEntity) {
-      const hasUsernameSemantic = Array.from(userEntity.properties).some(
-        (p) => typeof p.hasSemantic === 'function' && p.hasSemantic(SemanticType.Username)
-      )
-      if (!hasUsernameSemantic) {
+      let usernameProp: DomainProperty | undefined
+      for (const prop of userEntity.properties) {
+        if (prop.hasSemantic(SemanticType.Username)) {
+          usernameProp = prop
+          break
+        }
+      }
+      if (!usernameProp) {
         issues.push({
           code: createCode('API', 'MISSING_USERNAME_SEMANTIC'),
           message: 'Username & Password authentication requires a field with the Username data semantic.',
@@ -177,24 +174,21 @@ export function validateApiModelSecurity(model: ApiModel): ApiModelValidationIte
       context: { ...context, property: 'authorization' },
     })
   } else if (model.authorization.strategy === 'RBAC') {
-    const rbac = model.authorization as RolesBasedAccessControl
-    if (!rbac.roleKey) {
-      issues.push({
-        code: createCode('API', 'MISSING_ROLE_KEY'),
-        message: 'Role-based access control is selected but no role field has been defined.',
-        suggestion: "Select which field in your user profile determines the user's role.",
-        severity: 'error',
-        context: { ...context, property: 'authorization.roleKey' },
-      })
-    } else if (userEntity) {
-      const roleProp = Array.from(userEntity.properties).find((p) => p.key === rbac.roleKey)
-      if (roleProp && !roleProp.hasSemantic(SemanticType.UserRole)) {
+    if (userEntity) {
+      let roleProp: DomainProperty | undefined
+      for (const prop of userEntity.properties) {
+        if (prop.hasSemantic(SemanticType.UserRole)) {
+          roleProp = prop
+          break
+        }
+      }
+      if (!roleProp) {
         issues.push({
           code: createCode('API', 'MISSING_ROLE_SEMANTIC'),
-          message: 'The selected role field is missing the User Role data semantic.',
-          suggestion: 'Go to the Data Modeler and add the "User Role" semantic to this property.',
+          message: 'Role-based access control requires a property with the User Role data semantic on the user model.',
+          suggestion: 'Go to the Data Modeler and add the "User Role" semantic to the property used for roles.',
           severity: 'error',
-          context: { ...context, property: 'authorization.roleKey' },
+          context: { ...context, property: 'user' },
         })
       }
     }
@@ -229,15 +223,23 @@ export function validateApiModelSecurity(model: ApiModel): ApiModelValidationIte
         context: { ...context, property: 'session.properties' },
       })
     } else if (model.authorization && model.authorization.strategy === 'RBAC') {
-      const rbac = model.authorization as RolesBasedAccessControl
-      if (rbac.roleKey && !model.session.properties.includes(rbac.roleKey)) {
-        issues.push({
-          code: createCode('API', 'MISSING_RBAC_SESSION_PROPERTY'),
-          message: 'The user role must be included in the session data for permissions to work.',
-          suggestion: 'Make sure your selected role field is checked in the session settings.',
-          severity: 'error',
-          context: { ...context, property: 'session.properties' },
-        })
+      if (userEntity) {
+        let roleProp: DomainProperty | undefined
+        for (const prop of userEntity.properties) {
+          if (prop.hasSemantic(SemanticType.UserRole)) {
+            roleProp = prop
+            break
+          }
+        }
+        if (roleProp && !model.session.properties.includes(roleProp.key)) {
+          issues.push({
+            code: createCode('API', 'MISSING_RBAC_SESSION_PROPERTY'),
+            message: 'The user role must be included in the session data for permissions to work.',
+            suggestion: 'Make sure your selected role property is checked in the session settings.',
+            severity: 'error',
+            context: { ...context, property: 'session.properties' },
+          })
+        }
       }
     }
 

package/src/modeling/validation/api_model_validation_rules.md

@@ -23,9 +23,9 @@ Validations are evaluated with one of three severity levels:
 ## 3. Security & Access Control
 
 - **Authentication** [Error]: The `authentication` configuration is required.
-  - If the strategy is `UsernamePassword`, the `passwordKey` must be defined.
+  - If the strategy is `UsernamePassword`, the user entity must contain a property with the `Username` semantic.
 - **Authorization** [Error]: The `authorization` configuration is required.
-  - If the strategy is `RBAC`, the `roleKey` must be defined.
+  - If the strategy is `RBAC`, the user entity must contain a property with the `UserRole` semantic.
 - **Session Configuration** [Error]: The `session` configuration is required and must meet the following criteria:
   - **Secret**: A session encryption token (`secret`) is required.
   - **Properties**: The `session.properties` array must have at least one property set (e.g. to identify the User ID).

package/src/models/store/CustomDomain.ts

@@ -36,7 +36,7 @@ export interface CustomDomainSchema {
   updatedAt: number
 }
 
-export class CustomDomainModel implements CustomDomainSchema {
+export class CustomDomain implements CustomDomainSchema {
   id: string
   orgId: string
   domain: string
@@ -64,7 +64,7 @@ export class CustomDomainModel implements CustomDomainSchema {
   }
 
   constructor(state?: Partial<CustomDomainSchema>) {
-    const init = CustomDomainModel.createSchema(state)
+    const init = CustomDomain.createSchema(state)
     this.id = init.id
     this.orgId = init.orgId
     this.domain = init.domain

package/src/models/store/DeploymentCustomDomain.ts

@@ -40,7 +40,7 @@ export interface DeploymentCustomDomainSchema {
   updatedAt: number
 }
 
-export class DeploymentCustomDomainModel implements DeploymentCustomDomainSchema {
+export class DeploymentCustomDomain implements DeploymentCustomDomainSchema {
   id: string
   deploymentId: string
   customDomainId: string
@@ -63,7 +63,7 @@ export class DeploymentCustomDomainModel implements DeploymentCustomDomainSchema
   }
 
   constructor(state?: Partial<DeploymentCustomDomainSchema>) {
-    const init = DeploymentCustomDomainModel.createSchema(state)
+    const init = DeploymentCustomDomain.createSchema(state)
     this.id = init.id
     this.deploymentId = init.deploymentId
     this.customDomainId = init.customDomainId

package/src/models/store/File.ts

@@ -2,10 +2,10 @@ import { nanoid } from '../../nanoid.js'
 import { PermissionSchema, Permission, PermissionRole } from './Permission.js'
 import { ModificationSchema } from './Modification.js'
 import { DeletionSchema } from './Deletion.js'
-import { UserSchema, Kind as UserKind } from './User.js'
+import { UserSchema } from './User.js'
 import { ThingSchema, Thing } from '../Thing.js'
 import { CapabilitiesSchema } from './Capabilities.js'
-import { FolderKind } from '../kinds.js'
+import { FolderKind, UserKind } from '../kinds.js'
 // this causes error
 // import { Kind as FolderKind } from '../Folder.js';
 

package/src/models/store/User.ts

@@ -1,5 +1,6 @@
 import type { DeletionSchema } from './Deletion.js'
 import type { UserOrganizationGrantType } from './Organization.js'
+import { UserKind } from '../kinds.js'
 
 export interface EmailSchema {
   /**
@@ -34,8 +35,6 @@ export interface UserPictureSchema {
  */
 export type IUserPicture = UserPictureSchema
 
-export const Kind = 'Core#User'
-
 export type UserStatus = 'active' | 'deleted' | 'suspended' | 'pending'
 
 /**
@@ -47,7 +46,7 @@ export type UserStatus = 'active' | 'deleted' | 'suspended' | 'pending'
  * identity providers. However, this is not exposed to the user through the API.
  */
 export interface UserSchema {
-  kind: typeof Kind
+  kind: typeof UserKind
   /**
    * The data store key of the user.
    */
@@ -59,7 +58,7 @@ export interface UserSchema {
   /**
    * When available the email of the user.
    */
-  email: IEmail[]
+  email: EmailSchema[]
   /**
    * The user picture to render.
    */

package/src/sdk/GroupsSdk.ts

@@ -1,4 +1,4 @@
-import { ContextListOptions, ContextListResult } from '../browser.js'
+import type { ContextListOptions, ContextListResult } from '../events/BaseEvents.js'
 import { Exception } from '../exceptions/exception.js'
 import type { GroupSchema } from '../models/store/Group.js'
 import { RouteBuilder } from './RouteBuilder.js'

package/src/sdk/StoreSdkNode.ts

@@ -4,17 +4,6 @@ import { Sdk } from './Sdk.js'
 import { Http } from './Http.js'
 import { WsClient } from './WsClient.js'
 
-export type { IStoreResponse, IStoreRequestOptions } from './SdkBase.js'
-export type { IMetaCreateOptions, IMediaCreateOptions, IFileCreateOptions, ListFileKind } from './FilesSdk.js'
-export type {
-  IJwtInfo,
-  IJwtUser,
-  RegistrationInfoSchema,
-  OrganizationRegistrationInfoSchema,
-  OrganizationAddUserInfoSchema,
-} from './UsersSdk.js'
-export type { DataCatalogListOptions } from './DataCatalogSdk.js'
-
 /**
  * NodeJS API for API Client's net-store module.
  */

package/src/sdk/StoreSdkWeb.ts

@@ -4,19 +4,8 @@ import { Sdk } from './Sdk.js'
 import { Http } from './Http.js'
 import { WsClient } from './WsClient.js'
 
-export type { IStoreResponse, IStoreRequestOptions } from './SdkBase.js'
-export type { IMetaCreateOptions, IMediaCreateOptions, IFileCreateOptions, ListFileKind } from './FilesSdk.js'
-export type {
-  IJwtInfo,
-  IJwtUser,
-  RegistrationInfoSchema,
-  OrganizationRegistrationInfoSchema,
-  OrganizationAddUserInfoSchema,
-} from './UsersSdk.js'
-export type { DataCatalogListOptions } from './DataCatalogSdk.js'
-
 /**
- * NodeJS API for API Client's net-store module.
+ * API Client's web store module.
  */
 export class StoreSdk extends Sdk {
   http: Http = new HttpWeb(this)

package/tests/unit/authorization/SecurityProcessor.spec.ts

@@ -1,5 +1,6 @@
 import { test } from '@japa/runner'
-import { SecurityProcessor, IOidcTokenInfo, HttpRequest, IHttpRequest, Property } from '../../../src/index.js'
+import { SecurityProcessor } from '../../../src/authorization/index.js'
+import { IOidcTokenInfo, HttpRequest, IHttpRequest, Property } from '../../../src/models/index.js'
 
 test.group('applyBasicAuth()', (group) => {
   let request: IHttpRequest

package/tests/unit/data/JmesparthReader.spec.ts

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { JmespathReader } from '../../../src/index.js'
+import { JmespathReader } from '../../../src/data/index.js'
 
 test.group('JmespathReader', () => {
   test('returns a value for a simple path', async ({ assert }) => {

package/tests/unit/data/JsonReader.spec.ts

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { JsonReader } from '../../../src/index.js'
+import { JsonReader } from '../../../src/data/index.js'
 
 test.group('JsonReader', () => {
   test('returns a value for a simple path', async ({ assert }) => {

package/tests/unit/data/PayloadPointer.spec.ts

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { PayloadPointer } from '../../../src/index.js'
+import { PayloadPointer } from '../../../src/data/index.js'
 
 test.group('PayloadPointer', () => {
   test('returns a value for a json - exact match', async ({ assert }) => {

package/tests/unit/data/RequestDataExtractor.spec.ts

@@ -1,12 +1,8 @@
 import { test } from '@japa/runner'
-import {
-  RequestDataExtractor,
-  HttpRequestKind,
-  IHttpRequest,
-  HttpResponseKind,
-  IHttpResponse,
-  HttpResponse,
-} from '../../../src/index.js'
+import { RequestDataExtractor } from '../../../src/data/index.js'
+import { HttpRequestKind, IHttpRequest, IHttpResponse, HttpResponse } from '../../../src/models/index.js'
+import { Kinds } from '../../../src/index.js'
+
 import { FlowSourceEnum, FlowRequestDataEnum, FlowResponseDataEnum } from '../../../src/models/http-flows/HttpFlows.js'
 
 test.group('constructor()', () => {
@@ -34,13 +30,13 @@ test.group('constructor()', () => {
         method: 'GET',
       },
       {
-        kind: HttpResponseKind,
+        kind: Kinds.HttpResponseKind,
         status: 200,
       }
     )
     assert.typeOf(instance.response, 'object', 'has the object')
     const response = instance.response as HttpResponse
-    assert.equal(response.kind, HttpResponseKind, 'has the HttpResponse instance')
+    assert.equal(response.kind, Kinds.HttpResponseKind, 'has the HttpResponse instance')
   })
 })
 
@@ -190,7 +186,7 @@ test.group('response headers', (group) => {
     }
     response = {
       status: 200,
-      kind: HttpResponseKind,
+      kind: Kinds.HttpResponseKind,
       headers: 'x-t1: true\naccept: text/plain',
     }
   })
@@ -238,7 +234,7 @@ test.group('status extraction', (group) => {
     }
     response = {
       status: 200,
-      kind: HttpResponseKind,
+      kind: Kinds.HttpResponseKind,
     }
   })
 
@@ -282,7 +278,7 @@ test.group('data source selection', (group) => {
     }
     response = {
       status: 200,
-      kind: HttpResponseKind,
+      kind: Kinds.HttpResponseKind,
       payload: 'response-payload',
     }
   })

package/tests/unit/data/UrlEncodedReader.spec.ts

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { UrlEncodedReader } from '../../../src/index.js'
+import { UrlEncodedReader } from '../../../src/data/index.js'
 
 test.group('UrlEncodedReader', () => {
   test('returns a value for a simple path', async ({ assert }) => {

package/tests/unit/data/XmlReader.spec.ts

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { XmlReader } from '../../../src/index.js'
+import { XmlReader } from '../../../src/data/index.js'
 
 test.group('XmlReader', () => {
   const cities = `

package/tests/unit/mocking/current/Certificates.spec.ts

@@ -2,7 +2,7 @@ import { test } from '@japa/runner'
 import sinon from 'sinon'
 import { Certificates } from '../../../../src/mocking/lib/Certificates.js'
 import { Certificate, IPemCertificate } from '../../../../src/models/ClientCertificate.js'
-import type { HttpCertificate } from '../../../../src/index.js'
+import { HttpCertificate } from '../../../../src/models/index.js'
 
 test.group('certificate()', (group) => {
   let certs: Certificates

package/tests/unit/mocking/current/HostRules.spec.ts

@@ -1,7 +1,7 @@
 import { test } from '@japa/runner'
 import sinon from 'sinon'
 import { HostRules } from '../../../../src/mocking/lib/HostRules.js'
-import type { IHostRule } from '../../../../src/index.js'
+import { IHostRule } from '../../../../src/models/index.js'
 
 test.group('rule()', (group) => {
   let rules: HostRules

package/tests/unit/mocking/current/Urls.spec.ts

@@ -1,7 +1,7 @@
 import { test } from '@japa/runner'
 import sinon from 'sinon'
 import { Url } from '../../../../src/mocking/lib/Url.js'
-import type { IUrl } from '../../../../src/index.js'
+import type { IUrl } from '../../../../src/models/index.js'
 
 test.group('url()', (group) => {
   let urls: Url

package/tests/unit/mocking/current/User.spec.ts

@@ -1,7 +1,7 @@
 import { test } from '@japa/runner'
 import { User } from '../../../../src/mocking/lib/User.js'
-import { Kind as UserKind } from '../../../../src/models/store/User.js'
-import type { UserSchema } from '../../../../src/index.js'
+import { UserKind } from '../../../../src/models/kinds.js'
+import type { UserSchema } from '../../../../src/models/index.js'
 
 test.group('user()', (group) => {
   let user: User