@ditojs/server 2.86.0 → 2.88.0

package/types/tests/application.test-d.ts

@@ -0,0 +1,26 @@
+import { expectTypeOf, describe, it } from 'vitest'
+import type { Application, Model } from '../index.d.ts'
+import type { app } from './fixtures.ts'
+
+describe('Application', () => {
+  it('models property exists', () => {
+    type App = typeof app
+    expectTypeOf<App['models']>()
+      .not.toBeAny()
+    expectTypeOf<App['models']>().toHaveProperty('Item')
+    expectTypeOf<App['models']>().toHaveProperty('User')
+  })
+
+  it('start and stop return promises', () => {
+    type App = typeof app
+    expectTypeOf<ReturnType<App['start']>>()
+      .toEqualTypeOf<Promise<void>>()
+    expectTypeOf<ReturnType<App['stop']>>()
+      .toEqualTypeOf<Promise<void>>()
+  })
+
+  it('addModels accepts model class map', () => {
+    type App = typeof app
+    expectTypeOf<App['addModels']>().toBeFunction()
+  })
+})

package/types/tests/controller.test-d.ts

@@ -0,0 +1,113 @@
+import { expectTypeOf, assertType, describe, it } from 'vitest'
+import type {
+  Controller,
+  ModelController,
+  CollectionController,
+  RelationController,
+  QueryBuilder,
+  Model,
+  KoaContext,
+  ModelControllerActionHandler,
+  ControllerActionHandler
+} from '../index.d.ts'
+import type { Transaction } from 'objection'
+
+describe('Controller', () => {
+  it('getMember accepts ctx and returns Promise<Model | null>', () => {
+    const ctrl = {} as Controller
+    expectTypeOf(ctrl.getMember({} as KoaContext)).toEqualTypeOf<
+      Promise<Model | null>
+    >()
+  })
+
+  it('setProperty accepts string key and unknown value', () => {
+    const ctrl = {} as Controller
+    expectTypeOf(ctrl.setProperty).toBeFunction()
+    ctrl.setProperty('foo', 42)
+    ctrl.setProperty('bar', 'hello')
+  })
+
+  it('action handler this is typed to controller', () => {
+    type Handler = ControllerActionHandler<Controller>
+    const handler: Handler = function (ctx) {
+      expectTypeOf(this).not.toBeAny()
+      expectTypeOf(this).toEqualTypeOf<Controller>()
+      expectTypeOf(ctx).not.toBeAny()
+      expectTypeOf(ctx).toMatchTypeOf<KoaContext>()
+    }
+  })
+})
+
+describe('CollectionController', () => {
+  it('getMember returns typed model or null', () => {
+    const ctrl = {} as CollectionController<Model>
+    const result = ctrl.getMember(
+      {} as KoaContext,
+      undefined,
+      { forUpdate: true }
+    )
+    expectTypeOf(result).toEqualTypeOf<Promise<Model | null>>()
+  })
+
+  it('executeAndFetch modify receives query and trx', () => {
+    const ctrl = {} as CollectionController<Model>
+    ctrl.executeAndFetch(
+      'patch',
+      {} as KoaContext,
+      (query, trx) => {
+        expectTypeOf(query).not.toBeAny()
+        expectTypeOf(query)
+          .toMatchTypeOf<QueryBuilder<Model>>()
+        expectTypeOf(trx).not.toBeAny()
+        expectTypeOf(trx)
+          .toEqualTypeOf<Transaction | undefined>()
+      }
+    )
+  })
+
+  it('executeAndFetchById modify receives query and trx', () => {
+    const ctrl = {} as CollectionController<Model>
+    ctrl.executeAndFetchById(
+      'patch',
+      {} as KoaContext,
+      (query, trx) => {
+        expectTypeOf(query).not.toBeAny()
+        expectTypeOf(query)
+          .toMatchTypeOf<QueryBuilder<Model>>()
+        expectTypeOf(trx).not.toBeAny()
+        expectTypeOf(trx)
+          .toEqualTypeOf<Transaction | undefined>()
+      }
+    )
+  })
+})
+
+describe('ModelController', () => {
+  it('action handler this is typed to the controller', () => {
+    type Handler = ModelControllerActionHandler<ModelController<Model>>
+    const handler: Handler = function (ctx) {
+      expectTypeOf(this).not.toBeAny()
+      expectTypeOf(this)
+        .toEqualTypeOf<ModelController<Model>>()
+      expectTypeOf(ctx).not.toBeAny()
+      expectTypeOf(ctx).toMatchTypeOf<KoaContext>()
+    }
+  })
+})
+
+describe('RelationController', () => {
+  it('parent is CollectionController', () => {
+    const ctrl = {} as RelationController<Model>
+    expectTypeOf(
+      ctrl.parent
+    ).toMatchTypeOf<CollectionController>()
+  })
+
+  it('has relation-specific properties', () => {
+    const ctrl = {} as RelationController<Model>
+    expectTypeOf(ctrl.isOneToOne).toBeBoolean()
+    expectTypeOf(ctrl.relate).toBeBoolean()
+    expectTypeOf(ctrl.unrelate).toBeBoolean()
+    expectTypeOf(ctrl.object).toEqualTypeOf<Record<string, unknown>>()
+  })
+})

package/types/tests/errors.test-d.ts

@@ -0,0 +1,53 @@
+import { expectTypeOf, describe, it } from 'vitest'
+import type {
+  ResponseError,
+  NotFoundError,
+  ValidationError,
+  DatabaseError,
+  ControllerError,
+  AuthorizationError,
+  AuthenticationError,
+  ModelError,
+  GraphError
+} from '../index.d.ts'
+
+describe('Errors', () => {
+  it('ResponseError has status and is an Error', () => {
+    const err = {} as ResponseError
+    expectTypeOf(err.status).toBeNumber()
+    expectTypeOf(err.message).toBeString()
+    expectTypeOf(err).toMatchTypeOf<Error>()
+  })
+
+  it('NotFoundError extends ResponseError', () => {
+    expectTypeOf<NotFoundError>().toMatchTypeOf<ResponseError>()
+  })
+
+  it('ValidationError extends ResponseError', () => {
+    expectTypeOf<ValidationError>().toMatchTypeOf<ResponseError>()
+  })
+
+  it('DatabaseError extends ResponseError', () => {
+    expectTypeOf<DatabaseError>().toMatchTypeOf<ResponseError>()
+  })
+
+  it('ControllerError extends ResponseError', () => {
+    expectTypeOf<ControllerError>().toMatchTypeOf<ResponseError>()
+  })
+
+  it('AuthorizationError extends ResponseError', () => {
+    expectTypeOf<AuthorizationError>().toMatchTypeOf<ResponseError>()
+  })
+
+  it('AuthenticationError extends ResponseError', () => {
+    expectTypeOf<AuthenticationError>().toMatchTypeOf<ResponseError>()
+  })
+
+  it('GraphError extends ResponseError', () => {
+    expectTypeOf<GraphError>().toMatchTypeOf<ResponseError>()
+  })
+
+  it('ModelError extends ResponseError', () => {
+    expectTypeOf<ModelError>().toMatchTypeOf<ResponseError>()
+  })
+})

package/types/tests/fixtures.ts

@@ -0,0 +1,19 @@
+import type { Model, Application } from '../index.d.ts'
+
+// Test model types that don't narrow `id` from `Id` to avoid
+// variance issues with QueryBuilder's PartialModelObject<M>.
+export interface Item extends Model {
+  title: string
+  active: boolean
+}
+
+export interface User extends Model {
+  name: string
+  email: string
+  items: Item[]
+}
+
+export const app = {} as Application<{
+  Item: typeof Model
+  User: typeof Model
+}>

package/types/tests/model.test-d.ts

@@ -0,0 +1,193 @@
+import { expectTypeOf, assertType, describe, it } from 'vitest'
+import type {
+  Model,
+  QueryBuilder,
+  SerializedModel,
+  ModelScopes,
+  ModelFilters,
+  ModelHooks,
+  ModelFilterFunction,
+  ModelProperty
+} from '../index.d.ts'
+import type { View } from '../../../admin/types/index.d.ts'
+import type { Transaction } from 'objection'
+import type { Item } from './fixtures.ts'
+
+describe('Model', () => {
+  it('initialize returns void or Promise<void>', () => {
+    expectTypeOf<typeof Model.initialize>()
+      .returns.toEqualTypeOf<void | Promise<void>>()
+  })
+
+  it('getAttributes requires a filter function', () => {
+    expectTypeOf<typeof Model.getAttributes>()
+      .toBeCallableWith(
+        (prop: ModelProperty) => true
+      )
+    expectTypeOf<typeof Model.getAttributes>()
+      .parameter(0)
+      .not.toBeUndefined()
+  })
+
+  it('$patch accepts Date for date fields', () => {
+    interface TimestampedItem extends Model {
+      title: string
+      createdAt: Date
+    }
+    const item = {} as TimestampedItem
+    item.$patch({ title: 'test' })
+    item.$patch({ createdAt: new Date() })
+  })
+
+  it('$is accepts Model, null, or undefined', () => {
+    const item = {} as Item
+    expectTypeOf(item.$is)
+      .parameter(0)
+      .toEqualTypeOf<Model | null | undefined>()
+    assertType<boolean>(item.$is(null))
+    assertType<boolean>(item.$is(undefined))
+    assertType<boolean>(item.$is({} as Item))
+  })
+
+  it('$transaction handler overload', () => {
+    const item = {} as Item
+    assertType<Promise<any>>(
+      item.$transaction(async trx => {
+        expectTypeOf(trx).not.toBeAny()
+        expectTypeOf(trx).toMatchTypeOf<Transaction>()
+      })
+    )
+  })
+
+  it('$transaction trx + handler overload', () => {
+    const item = {} as Item
+    assertType<Promise<any>>(
+      item.$transaction(
+        {} as Transaction,
+        async trx => {
+          expectTypeOf(trx).not.toBeAny()
+          expectTypeOf(trx)
+            .toMatchTypeOf<Transaction>()
+        }
+      )
+    )
+  })
+
+  it('static transaction overloads exist', () => {
+    expectTypeOf<typeof Model.transaction>()
+      .toBeCallableWith()
+    expectTypeOf<typeof Model.transaction>()
+      .toBeCallableWith(async (trx: any) => {})
+  })
+
+  it('scopes handler receives query and applyParentScope', () => {
+    const scopes: ModelScopes<Model> = {
+      active(query, applyParentScope) {
+        expectTypeOf(query).not.toBeAny()
+        expectTypeOf(query)
+          .toMatchTypeOf<QueryBuilder<Model>>()
+        expectTypeOf(applyParentScope)
+          .not.toBeAny()
+        expectTypeOf(applyParentScope).toEqualTypeOf< (
+            query: QueryBuilder<Model>
+          ) => QueryBuilder<Model>
+        >()
+        return applyParentScope(query)
+      }
+    }
+    assertType<ModelScopes<Model>>(scopes)
+  })
+
+  it('filters handler receives typed query builder', () => {
+    const filter: ModelFilterFunction<Model> = (
+      query,
+      ...args
+    ) => {
+      expectTypeOf(query).not.toBeAny()
+      expectTypeOf(query)
+        .toMatchTypeOf<QueryBuilder<Model>>()
+      return query
+    }
+    assertType<ModelFilterFunction<Model>>(filter)
+  })
+
+  it('hooks keys match lifecycle patterns', () => {
+    const hooks: ModelHooks<Model> = {
+      'before:insert'(args) {
+        expectTypeOf(args).not.toBeAny()
+      },
+      'after:find'(args) {
+        expectTypeOf(args).not.toBeAny()
+      },
+      'before:update'(args) {
+        expectTypeOf(args).not.toBeAny()
+      },
+      'after:delete'(args) {
+        expectTypeOf(args).not.toBeAny()
+      }
+    }
+    assertType<ModelHooks<Model>>(hooks)
+  })
+
+  it('QueryBuilderType uses Dito QueryBuilder', () => {
+    const model = {} as Model
+    expectTypeOf(model.QueryBuilderType).toEqualTypeOf<
+      QueryBuilder<Model, Model[]>
+    >()
+  })
+})
+
+describe('SerializedModel', () => {
+  it('strips functions, $-prefixed, and internal keys', () => {
+    interface TestModel extends Model {
+      title: string
+      $meta: string
+    }
+    type Result = SerializedModel<TestModel>
+    expectTypeOf<keyof Result>()
+      .toEqualTypeOf<'id' | 'title'>()
+  })
+
+  it('converts Date properties to string (JSON serialization)', () => {
+    interface TimestampedModel extends Model {
+      createdAt: Date
+      updatedAt?: Date
+      timestamps: Date[]
+    }
+    type Result = SerializedModel<TimestampedModel>
+    expectTypeOf<Result['createdAt']>()
+      .toEqualTypeOf<string>()
+    expectTypeOf<Result['updatedAt']>()
+      .toEqualTypeOf<string | undefined>()
+    expectTypeOf<Result['timestamps']>()
+      .toEqualTypeOf<string[]>()
+  })
+
+  it('View<SerializedModel<T>> assignable to View<any> through Record', () => {
+    interface StreamCheckModel extends Model {
+      result: string
+      functioning: boolean
+      channelId: number
+      createdAt: Date
+      src: string
+      logs?: Record<string, any>[]
+    }
+    type StreamCheck = SerializedModel<StreamCheckModel>
+    const view: View<StreamCheck> = {
+      type: 'view',
+      components: {
+        result: { type: 'text' }
+      },
+      panels: {
+        info: {
+          type: 'panel',
+          components: {
+            src: { type: 'text' }
+          }
+        }
+      }
+    }
+    const views = { streamChecks: view }
+    assertType<Record<string, View<any>>>(views)
+  })
+})

package/types/tests/query-builder.test-d.ts

@@ -0,0 +1,106 @@
+import { expectTypeOf, assertType, describe, it } from 'vitest'
+import type { QueryBuilder, Model } from '../index.d.ts'
+
+describe('QueryBuilder', () => {
+  type QB = QueryBuilder<Model, Model[]>
+
+  it('applyFilter supports string name with args', () => {
+    const query = {} as QB
+    assertType<QB>(query.applyFilter('active'))
+    assertType<QB>(query.applyFilter('recent', 30))
+  })
+
+  it('applyFilter supports object notation', () => {
+    const query = {} as QB
+    assertType<QB>(
+      query.applyFilter({ active: [], recent: [30] })
+    )
+  })
+
+  it('applyFilter rejects wrong argument types', () => {
+    const query = {} as QB
+    // @ts-expect-error - first arg must be string or object
+    query.applyFilter(123)
+  })
+
+  it('upsert options are individually optional', () => {
+    const query = {} as QB
+    assertType<QB>(query.upsert({} as any, { update: true }))
+    assertType<QB>(query.upsert({} as any, { fetch: true }))
+    assertType<QB>(query.upsert({} as any, {}))
+    assertType<QB>(query.upsert({} as any))
+  })
+
+  it('scope methods return this for chaining', () => {
+    const query = {} as QB
+    assertType<QB>(query.withScope('active'))
+    assertType<QB>(query.clearWithScope())
+    assertType<QB>(query.ignoreScope('default'))
+    assertType<QB>(query.applyScope('active'))
+  })
+
+  it('withGraph returns this for chaining', () => {
+    const query = {} as QB
+    assertType<QB>(query.withGraph('[items]'))
+    assertType<QB>(
+      query.withGraph('[items]', { algorithm: 'fetch' })
+    )
+  })
+
+  it('find returns this for chaining', () => {
+    const query = {} as QB
+    assertType<QB>(query.find({}))
+    assertType<QB>(
+      query.find({}, { scope: true, filter: false })
+    )
+  })
+
+  it('DitoGraph methods return this for chaining', () => {
+    const query = {} as QB
+    assertType<QB>(query.insertDitoGraph({} as any))
+    assertType<QB>(query.insertDitoGraphAndFetch({} as any))
+    assertType<QB>(query.upsertDitoGraph({} as any))
+    assertType<QB>(query.upsertDitoGraphAndFetch({} as any))
+    assertType<QB>(query.patchDitoGraph({} as any))
+    assertType<QB>(query.patchDitoGraphAndFetch({} as any))
+    assertType<QB>(
+      query.upsertDitoGraphAndFetchById(1, {} as any)
+    )
+    assertType<QB>(
+      query.updateDitoGraphAndFetchById(1, {} as any)
+    )
+    assertType<QB>(
+      query.patchDitoGraphAndFetchById(1, {} as any)
+    )
+  })
+
+  it('truncate accepts optional restart and cascade', () => {
+    const query = {} as QB
+    assertType<QB>(query.truncate())
+    assertType<QB>(
+      query.truncate({ restart: true, cascade: true })
+    )
+  })
+
+  it('pluck returns this for chaining', () => {
+    const query = {} as QB
+    assertType<QB>(query.pluck('title'))
+  })
+
+  it('toSQL returns sql and bindings', () => {
+    const query = {} as QB
+    const result = query.toSQL()
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result.sql).not.toBeAny()
+    expectTypeOf(result.sql).toBeString()
+    expectTypeOf(result.bindings)
+      .not.toBeAny()
+    expectTypeOf(result.bindings)
+      .toEqualTypeOf<unknown[]>()
+  })
+
+  it('omit returns void (not chainable)', () => {
+    const query = {} as QB
+    expectTypeOf(query.omit('id')).toBeVoid()
+  })
+})

package/types/tests/relation.test-d.ts

@@ -0,0 +1,83 @@
+import { assertType, describe, it } from 'vitest'
+import type { ModelRelation, QueryBuilder } from '../index.d.ts'
+
+describe('ModelRelation', () => {
+  it('accepts basic belongsTo relation', () => {
+    assertType<ModelRelation>({
+      relation: 'belongsTo',
+      from: 'Item.userId',
+      to: 'User.id'
+    })
+  })
+
+  it('accepts hasMany with scope and filter string', () => {
+    assertType<ModelRelation>({
+      relation: 'hasMany',
+      from: 'User.id',
+      to: 'Item.userId',
+      scope: 'active',
+      filter: 'published'
+    })
+  })
+
+  it('accepts filter as object with args', () => {
+    assertType<ModelRelation>({
+      relation: 'hasMany',
+      from: 'User.id',
+      to: 'Item.userId',
+      filter: { recent: [30], active: [] }
+    })
+  })
+
+  it('accepts modify as function', () => {
+    assertType<ModelRelation>({
+      relation: 'hasMany',
+      from: 'User.id',
+      to: 'Item.userId',
+      modify: query => {
+        query.withScope('active')
+      }
+    })
+  })
+
+  it('accepts modify as find-filter object', () => {
+    assertType<ModelRelation>({
+      relation: 'hasMany',
+      from: 'User.id',
+      to: 'Item.userId',
+      modify: { active: true }
+    })
+  })
+
+  it('accepts through relation with extra', () => {
+    assertType<ModelRelation>({
+      relation: 'manyToMany',
+      from: 'User.id',
+      to: 'Tag.id',
+      through: {
+        from: 'UserTag.userId',
+        to: 'UserTag.tagId',
+        extra: ['role']
+      },
+      inverse: true
+    })
+  })
+
+  it('accepts owner and nullable options', () => {
+    assertType<ModelRelation>({
+      relation: 'belongsTo',
+      from: 'Item.userId',
+      to: 'User.id',
+      owner: true,
+      nullable: true
+    })
+  })
+
+  it('rejects invalid relation type', () => {
+    // @ts-expect-error - relation is required
+    assertType<ModelRelation>({
+      from: 'Item.userId',
+      to: 'User.id'
+    })
+  })
+})