@api-client/core 0.12.6 → 0.12.9

package/src/runtime/store/OrganizationsSdk.ts

@@ -7,9 +7,11 @@ import {
   SdkOptions,
 } from './SdkBase.js'
 import { RouteBuilder } from './RouteBuilder.js'
-import { ContextListResult } from '../../events/BaseEvents.js'
-import { IOrganization } from '../../models/store/Organization.js'
+import type { ContextListResult } from '../../events/BaseEvents.js'
+import type { IOrganization, UserOrganizationGrantType } from '../../models/store/Organization.js'
+import type { InvitationSchema } from '../../models/store/Invitation.js'
 import { SdkError } from './Errors.js'
+import type { PatchInfo } from '../../patch/types.js'
 
 export class OrganizationsSdk extends SdkBase {
   /**
@@ -37,10 +39,10 @@ export class OrganizationsSdk extends SdkBase {
     try {
       data = JSON.parse(result.body)
     } catch {
-      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}`)
     }
     if (!Array.isArray(data.items)) {
-      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`)
     }
     return data
   }
@@ -70,10 +72,227 @@ export class OrganizationsSdk extends SdkBase {
     try {
       data = JSON.parse(result.body)
     } catch {
-      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}`)
     }
     if (!data.kind) {
-      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`)
+    }
+    return data
+  }
+
+  /**
+   * Lists all invitations for a given organization.
+   * @param oid The organization ID.
+   * @param request The request options.
+   * @returns A promise that resolves to a list of invitations.
+   */
+  async listInvitations(oid: string, request: SdkOptions = {}): Promise<ContextListResult<InvitationSchema>> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.invitations(oid))
+    const result = await this.sdk.http.get(url.toString(), { token })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to list organization invitations. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: ContextListResult<InvitationSchema>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}`)
+    }
+    if (!Array.isArray(data.items)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`)
+    }
+    return data
+  }
+
+  /**
+   * Creates an invitation for a user to join an organization.
+   * @param oid The organization ID.
+   * @param email The email address of the user to invite.
+   * @param grant_type The type of grant for the user.
+   * @param name The name of the user (optional).
+   * @param request The request options.
+   * @returns A promise that resolves to the created invitation.
+   */
+  async createInvitation(
+    oid: string,
+    email: string,
+    grant_type: UserOrganizationGrantType,
+    name?: string,
+    request: SdkOptions = {}
+  ): Promise<InvitationSchema> {
+    const url = this.sdk.getUrl(RouteBuilder.invitations(oid))
+    const body = {
+      email,
+      name,
+      grant_type,
+    }
+    const result = await this.sdk.http.post(url.toString(), {
+      body: JSON.stringify(body),
+      token: request.token,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to create an invitation. '
+    if (result.status !== 200) {
+      throw new Error(`${E_PREFIX}Invalid response status: ${result.status}`)
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}Response has no value.`)
+    }
+    let data: InvitationSchema
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}`)
+    }
+    if (!data.kind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`)
+    }
+    return data
+  }
+
+  /**
+   * Finds an invitation by its token.
+   * @param oid The organization ID.
+   * @param token The invitation token.
+   * @param request The request options.
+   * @returns A promise that resolves to the found invitation.
+   */
+  async findInvitationByToken(oid: string, token: string, request: SdkOptions = {}): Promise<InvitationSchema> {
+    const url = this.sdk.getUrl(RouteBuilder.findInvitation(oid))
+    url.searchParams.append('token', token)
+    const result = await this.sdk.http.get(url.toString(), request)
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to find invitation by token. '
+    if (result.status !== 200) {
+      throw new Error(`${E_PREFIX}Invalid response status: ${result.status}`)
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}Response has no value.`)
+    }
+    let data: InvitationSchema
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}`)
+    }
+    if (!data.kind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`)
+    }
+    return data
+  }
+
+  /**
+   * Declines an invitation.
+   * @param oid The organization ID.
+   * @param id The invitation ID.
+   * @param request The request options.
+   * @returns A promise that resolves when the invitation is declined.
+   */
+  async declineInvitation(oid: string, id: string, request: SdkOptions = {}): Promise<InvitationSchema> {
+    const url = this.sdk.getUrl(RouteBuilder.declineInvitation(oid, id))
+    const result = await this.sdk.http.post(url.toString(), request)
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to decline invitation. '
+    if (result.status !== 200) {
+      throw new Error(`${E_PREFIX}Invalid response status: ${result.status}`)
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}Response has no value.`)
+    }
+    let data: InvitationSchema
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}`)
+    }
+    if (!data.kind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`)
+    }
+    return data
+  }
+
+  /**
+   * Soft-deletes an invitation.
+   * @param oid The organization ID.
+   * @param id The invitation ID.
+   * @param request The request options.
+   * @returns A promise that resolves to the deleted invitation.
+   */
+  async deleteInvitation(oid: string, id: string, request: SdkOptions = {}): Promise<InvitationSchema> {
+    const url = this.sdk.getUrl(RouteBuilder.invitation(oid, id))
+    const result = await this.sdk.http.delete(url.toString(), request)
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to delete invitation. '
+    if (result.status !== 200) {
+      throw new Error(`${E_PREFIX}Invalid response status: ${result.status}`)
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}Response has no value.`)
+    }
+    let data: InvitationSchema
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}`)
+    }
+    if (!data.kind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`)
+    }
+    return data
+  }
+
+  /**
+   * Patches an invitation. The server performs the patch validation.
+   * The API only allows to patch some of the invitation properties:
+   * - name
+   * - expires_at
+   * - grant_type
+   * @param oid The organization ID.
+   * @param id The invitation ID.
+   * @param info The patch information.
+   * @param request The request options.
+   * @returns A promise that resolves to the patched invitation.
+   */
+  async patchInvitation(oid: string, id: string, info: PatchInfo, request: SdkOptions = {}): Promise<InvitationSchema> {
+    const url = this.sdk.getUrl(RouteBuilder.invitation(oid, id))
+    const result = await this.sdk.http.patch(url.toString(), {
+      body: JSON.stringify(info),
+      token: request.token,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to update invitation. '
+    if (result.status !== 200) {
+      throw new Error(`${E_PREFIX}Invalid response status: ${result.status}`)
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}Response has no value.`)
+    }
+    let data: InvitationSchema
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}`)
+    }
+    if (!data.kind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`)
     }
     return data
   }

package/src/runtime/store/RouteBuilder.ts

@@ -158,6 +158,34 @@ export class RouteBuilder {
     return '/v1/orgs'
   }
 
+  static organization(oid: string): string {
+    return `/v1/orgs/${oid}`
+  }
+
+  static users(oid: string): string {
+    return `${this.organization(oid)}/users`
+  }
+
+  static user(oid: string, key: string): string {
+    return `${this.organization(oid)}/users/${key}`
+  }
+
+  static invitations(oid: string): string {
+    return `${this.organization(oid)}/invitations`
+  }
+
+  static invitation(oid: string, id: string): string {
+    return `${this.invitations(oid)}/${id}`
+  }
+
+  static findInvitation(oid: string): string {
+    return `${this.invitations(oid)}/find`
+  }
+
+  static declineInvitation(oid: string, id: string): string {
+    return `${this.invitation(oid, id)}/decline`
+  }
+
   /**
    * @deprecated Not used anymore
    */
@@ -191,14 +219,6 @@ export class RouteBuilder {
     return '/v1/users/me'
   }
 
-  static users(oid: string): string {
-    return `/v1/orgs/${oid}/users`
-  }
-
-  static user(oid: string, key: string): string {
-    return `/v1/orgs/${oid}/users/${key}`
-  }
-
   static dataCatalog(): string {
     return '/v1/datacatalog'
   }

package/src/runtime/store/Sdk.ts

@@ -67,7 +67,7 @@ export abstract class Sdk {
 
   projectExecution = new ProjectExecutionSdk(this)
 
-  organization = new OrganizationsSdk(this)
+  organizations = new OrganizationsSdk(this)
 
   dataCatalog = new DataCatalogSdk(this)
   /**

package/src/runtime/store/SdkBase.ts

@@ -33,10 +33,10 @@ export interface IStoreResponse {
   body?: string
 }
 
-export const E_INVALID_JSON = 'The response is not a valid JSON.'
+export const E_INVALID_JSON = 'Invalid JSON response.'
 export const E_RESPONSE_NO_VALUE = 'The response has no value.'
 export const E_RESPONSE_STATUS = 'Invalid response status: '
-export const E_RESPONSE_UNKNOWN = 'The response has unknown format.'
+export const E_RESPONSE_UNKNOWN = 'Unknown response from the server.'
 export const E_RESPONSE_LOCATION = 'The response has no "location" header.'
 
 export class SdkBase {

package/tests/servers/express-routes/StreamApi.ts

@@ -1,13 +1,15 @@
 import { Router, Request, Response } from 'express'
+import { Lorem } from '@pawel-up/data-mock/Lorem.js'
+import { Types } from '@pawel-up/data-mock/Types.js'
 import { BaseApi } from './BaseApi.js'
 import cors from 'cors'
-import { DataMock } from '@pawel-up/data-mock'
 
 const router = Router()
 export default router
 
 class StreamRoute extends BaseApi {
-  #mock = new DataMock()
+  #lorem = new Lorem()
+  #types = new Types()
 
   async index(req: Request, res: Response): Promise<void> {
     res.writeHead(200, {
@@ -17,7 +19,7 @@ class StreamRoute extends BaseApi {
     this.#writeChunk(res)
     let time = 0
     for (let i = 0; i < 4; i++) {
-      const timeout = this.#mock.types.number({ min: 1, max: 10 })
+      const timeout = this.#types.number({ min: 1, max: 10 })
       time += timeout
       setTimeout(() => this.#writeChunk(res), timeout)
     }
@@ -28,7 +30,7 @@ class StreamRoute extends BaseApi {
   }
 
   #writeChunk(res: Response): void {
-    const word = this.#mock.lorem.word({ length: 128 })
+    const word = this.#lorem.word({ length: 128 })
     res.write(`${word}\n`)
   }
 }

package/tests/unit/models/store/Invitation.spec.ts

@@ -0,0 +1,223 @@
+import { test } from '@japa/runner'
+import { Invitation, InvitationKind, type InvitationSchema, type IDeletion } from '../../../../src/index.js'
+import { OperationType } from '@api-client/json/patch/types.js'
+
+const baseInput: Partial<InvitationSchema> = {
+  email: 'test@example.com',
+  oid: 'org-123',
+  grantType: 'viewer',
+}
+
+test.group('Invitation', (group) => {
+  group.tap((t) => t.tags(['@store', '@invitation']))
+
+  test('constructor initializes with minimal valid input', ({ assert }) => {
+    const invitation = new Invitation(baseInput)
+    assert.equal(invitation.kind, InvitationKind)
+    assert.isString(invitation.key)
+    assert.isNotEmpty(invitation.key)
+    assert.equal(invitation.email, baseInput.email)
+    assert.equal(invitation.oid, baseInput.oid)
+    assert.equal(invitation.grantType, baseInput.grantType)
+    assert.equal(invitation.uid, '') // default
+    assert.equal(invitation.token, '') // default
+    assert.equal(invitation.expiresAt, 0) // default
+    assert.equal(invitation.status, 'pending') // default
+    assert.isUndefined(invitation.name)
+    assert.isUndefined(invitation.respondedAt)
+    assert.isFalse(invitation.deleted)
+    assert.isUndefined(invitation.deletedInfo)
+    assert.equal(invitation.createdAt, 0) // default
+    assert.equal(invitation.updatedAt, 0) // default
+  })
+
+  test('constructor initializes with full input', ({ assert }) => {
+    const fullInput: InvitationSchema = {
+      kind: InvitationKind,
+      key: 'inv-key-123',
+      uid: 'user-abc',
+      oid: 'org-xyz',
+      email: 'full@example.com',
+      name: 'Test User',
+      token: 'secret-token',
+      expiresAt: Date.now() + 3600000,
+      respondedAt: Date.now(),
+      status: 'accepted',
+      grantType: 'editor',
+      deleted: true,
+      deletedInfo: { time: Date.now(), user: 'admin-user', byMe: false, name: 'Admin' },
+      createdAt: Date.now() - 7200000,
+      updatedAt: Date.now() - 3600000,
+    }
+    const invitation = new Invitation(fullInput)
+    assert.deepEqual(invitation.toJSON(), fullInput)
+  })
+
+  test('toJSON() serializes all properties correctly', ({ assert }) => {
+    const deletionInfo: IDeletion = { time: Date.now(), user: 'deleter-id', byMe: false, name: 'Deleter' }
+    const input: Partial<InvitationSchema> = {
+      ...baseInput,
+      key: 'inv-key-json',
+      uid: 'user-json',
+      name: 'JSON User',
+      token: 'json-token',
+      expiresAt: 1234567890,
+      respondedAt: 1234500000,
+      status: 'declined',
+      grantType: 'manager',
+      deleted: true,
+      deletedInfo: deletionInfo,
+      createdAt: 1230000000,
+      updatedAt: 1234000000,
+    }
+    const invitation = new Invitation(input)
+    const json = invitation.toJSON()
+
+    assert.deepEqual(json, {
+      kind: InvitationKind,
+      key: 'inv-key-json',
+      uid: 'user-json',
+      oid: baseInput.oid,
+      email: baseInput.email,
+      name: 'JSON User',
+      token: 'json-token',
+      expiresAt: 1234567890,
+      respondedAt: 1234500000,
+      status: 'declined',
+      grantType: 'manager',
+      deleted: true,
+      deletedInfo: deletionInfo,
+      createdAt: 1230000000,
+      updatedAt: 1234000000,
+    })
+  })
+
+  test('toJSON() omits optional fields when not set', ({ assert }) => {
+    const invitation = new Invitation(baseInput)
+    const json = invitation.toJSON()
+
+    assert.notProperty(json, 'name')
+    assert.notProperty(json, 'respondedAt')
+    assert.notProperty(json, 'deletedInfo') // deleted is false, so deletedInfo should not be present
+  })
+
+  test('getPatch() returns empty array when no changes', ({ assert }) => {
+    const invitation = new Invitation(baseInput)
+    assert.deepEqual(invitation.getPatch(), [])
+  })
+
+  test('setName() adds name if not present', ({ assert }) => {
+    const invitation = new Invitation(baseInput)
+    invitation.setName('New Name')
+    assert.deepEqual(invitation.getPatch(), [{ op: OperationType.add, path: '/name', value: 'New Name' }])
+  })
+
+  test('setName() replaces name if different', ({ assert }) => {
+    const invitation = new Invitation({ ...baseInput, name: 'Old Name' })
+    invitation.setName('New Name')
+    assert.deepEqual(invitation.getPatch(), [{ op: OperationType.replace, path: '/name', value: 'New Name' }])
+  })
+
+  test('setName() removes name if set to undefined', ({ assert }) => {
+    const invitation = new Invitation({ ...baseInput, name: 'Old Name' })
+    invitation.setName(undefined)
+    assert.deepEqual(invitation.getPatch(), [{ op: OperationType.remove, path: '/name' }])
+  })
+
+  test('setName() does nothing if name is the same', ({ assert }) => {
+    const invitation = new Invitation({ ...baseInput, name: 'Same Name' })
+    invitation.setName('Same Name')
+    assert.deepEqual(invitation.getPatch(), [])
+  })
+
+  test('setExpiresAt() replaces expiresAt if different', ({ assert }) => {
+    const invitation = new Invitation({ ...baseInput, expiresAt: 1000 })
+    invitation.setExpiresAt(2000)
+    assert.deepEqual(invitation.getPatch(), [{ op: OperationType.replace, path: '/expiresAt', value: 2000 }])
+  })
+
+  test('setExpiresAt() does nothing if expiresAt is the same', ({ assert }) => {
+    const invitation = new Invitation({ ...baseInput, expiresAt: 1000 })
+    invitation.setExpiresAt(1000)
+    assert.deepEqual(invitation.getPatch(), [])
+  })
+
+  test('setGrantType() replaces grantType if different', ({ assert }) => {
+    const invitation = new Invitation({ ...baseInput, grantType: 'viewer' })
+    invitation.setGrantType('editor')
+    assert.deepEqual(invitation.getPatch(), [{ op: OperationType.replace, path: '/grantType', value: 'editor' }])
+  })
+
+  test('setGrantType() does nothing if grantType is the same', ({ assert }) => {
+    const invitation = new Invitation({ ...baseInput, grantType: 'viewer' })
+    invitation.setGrantType('viewer')
+    assert.deepEqual(invitation.getPatch(), [])
+  })
+
+  test('builder getter initializes and returns builder', ({ assert }) => {
+    const invitation = new Invitation(baseInput)
+    const builder1 = invitation.builder
+    assert.isObject(builder1)
+    const builder2 = invitation.builder
+    assert.strictEqual(builder1, builder2) // Should return the same instance
+  })
+})
+
+test.group('Invitation.createSchema()', (schemaGroup) => {
+  schemaGroup.tap((t) => t.tags(['@store', '@invitation', '@static']))
+
+  test('throws if email is missing', ({ assert }) => {
+    assert.throws(
+      () => Invitation.createSchema({ oid: 'org-1', grantType: 'viewer' }),
+      'Email is required to create an invitation schema.'
+    )
+  })
+
+  test('throws if oid is missing', ({ assert }) => {
+    assert.throws(
+      () => Invitation.createSchema({ email: 'test@example.com', grantType: 'viewer' }),
+      'Organization ID is required to create an invitation schema.'
+    )
+  })
+
+  test('throws if grantType is missing', ({ assert }) => {
+    assert.throws(
+      () => Invitation.createSchema({ email: 'test@example.com', oid: 'org-1' }),
+      'Grant type is required to create an invitation schema.'
+    )
+  })
+
+  test('creates schema with all default values for optional fields', ({ assert }) => {
+    const schema = Invitation.createSchema(baseInput)
+    assert.equal(schema.kind, InvitationKind)
+    assert.isString(schema.key)
+    assert.equal(schema.uid, '')
+    assert.equal(schema.oid, baseInput.oid)
+    assert.equal(schema.email, baseInput.email)
+    assert.equal(schema.grantType, baseInput.grantType)
+    assert.equal(schema.token, '')
+    assert.equal(schema.expiresAt, 0)
+    assert.equal(schema.status, 'pending')
+    assert.equal(schema.createdAt, 0)
+    assert.equal(schema.updatedAt, 0)
+    assert.isUndefined(schema.name)
+    assert.isUndefined(schema.respondedAt)
+  })
+
+  test('creates schema with provided optional values', ({ assert }) => {
+    const partial: Partial<InvitationSchema> = {
+      ...baseInput,
+      name: 'Provided Name',
+      token: 'provided-token',
+      expiresAt: 999,
+      respondedAt: 888,
+      status: 'accepted',
+    }
+    const schema = Invitation.createSchema(partial)
+    assert.equal(schema.name, 'Provided Name')
+    assert.equal(schema.token, 'provided-token')
+    assert.equal(schema.expiresAt, 999)
+    assert.equal(schema.respondedAt, 888)
+    assert.equal(schema.status, 'accepted')
+  })
+})