@owlmeans/planning 0.1.18-rc.21 → 0.1.18-rc.22

package/src/helpers/scoped.ts

@@ -1,3 +1,5 @@
+import type { AssigneeTypeSchema } from '../resources/types.js'
+import { AssigneeTypeSchemaSchema } from '../schemas.js'
 import { memoHelper } from '@owlmeans/context'
 import { PlanningSchemaKind, SchemaOrigin, WorkcardKind } from '../consts.js'
 import { PlanningUnsupported, SchemaInvalid, SchemaSealed } from '../errors.js'
@@ -16,20 +18,25 @@ const messageOf = (error: unknown): string => error instanceof Error ? error.mes
 export const createScopedSchemaHelper = (): ScopedSchemaHelper => {
   const checkers = memoHelper.once(() => {
     const ajv = makeAjv()
-    return { flow: ajv.compile(StatusFlowSchemaSchema), type: ajv.compile(WorkcardTypeSchemaSchema) }
+    return { flow: ajv.compile(StatusFlowSchemaSchema), type: ajv.compile(WorkcardTypeSchemaSchema), assignee: ajv.compile(AssigneeTypeSchemaSchema) }
   })
 
   const schemaRecordKey = (record: Pick<ScopedSchemaRecord, 'entityId' | 'project' | 'kind' | 'key'>): string =>
     `${record.entityId}\u0000${record.project ?? ''}\u0000${record.kind}\u0000${record.key}`
 
-  const schemaKeyOf = (kind: PlanningSchemaKind, definition: WorkcardTypeSchema | StatusFlowSchema): string =>
-    kind === PlanningSchemaKind.Type ? (definition as WorkcardTypeSchema).type : (definition as StatusFlowSchema).id
+  const schemaKeyOf = (kind: PlanningSchemaKind, definition: WorkcardTypeSchema | StatusFlowSchema | AssigneeTypeSchema): string =>
+    kind !== PlanningSchemaKind.Flow ? (definition as WorkcardTypeSchema).type : (definition as StatusFlowSchema).id
 
   const openType = (type: AnyTypeSchema): boolean => type.kind === WorkcardKind.Card && type.overridable === true
 
   const assertOverridable = (
-    code: Pick<PlanningSchemaRegistry, 'has' | 'type' | 'flows'>, kind: PlanningSchemaKind, key: string
+    code: Pick<PlanningSchemaRegistry, 'has' | 'type' | 'flows' | 'assigneeTypes'>, kind: PlanningSchemaKind, key: string
   ): void => {
+    if (kind === PlanningSchemaKind.AssigneeType) {
+      const schema = code.assigneeTypes().find(schema => schema.type === key)
+      if (schema != null && schema.overridable !== true) throw new SchemaSealed(`assignee:${key}`)
+      return
+    }
     if (kind === PlanningSchemaKind.Type) {
       if (code.has(key) && !openType(code.type(key))) {
         throw new SchemaSealed(`type:${key}`)
@@ -42,6 +49,12 @@ export const createScopedSchemaHelper = (): ScopedSchemaHelper => {
     }
   }
 
+  const assertAssigneeTypeSchema = (schema: AssigneeTypeSchema): void => {
+    const validate = checkers().assignee
+    if (!validate(schema)) throw new SchemaInvalid(`assignee:${(schema as Partial<AssigneeTypeSchema>)?.type}:${validateHelper.ajvErrorText(validate.errors)}`)
+    try { makeAjv().compile(schema.fields) } catch (error) { throw new SchemaInvalid(`assignee:${schema.type}:fields:${messageOf(error)}`) }
+  }
+
   const assertFlowSchema = (flow: StatusFlowSchema): void => {
     const validate = checkers().flow
     if (!validate(flow)) {
@@ -100,7 +113,7 @@ export const createScopedSchemaHelper = (): ScopedSchemaHelper => {
     }
   }
 
-  const resolveKind = <T extends WorkcardTypeSchema | StatusFlowSchema | AnyTypeSchema>(
+  const resolveKind = <T extends WorkcardTypeSchema | StatusFlowSchema | AssigneeTypeSchema | AnyTypeSchema>(
     kind: PlanningSchemaKind,
     code: readonly T[],
     keyOf: (definition: T) => string,
@@ -171,14 +184,19 @@ export const createScopedSchemaHelper = (): ScopedSchemaHelper => {
       flow => flow != null && typeof flow.id === 'string', layers,
     )
 
+    const assignees = resolveKind<AssigneeTypeSchema>(
+      PlanningSchemaKind.AssigneeType, code.assigneeTypes ?? [], schema => schema.type, schema => schema.overridable === true,
+      schema => schema != null && typeof schema.type === 'string', { entity: layers.entity, project: [] },
+    )
     return structuredClone({
+      assigneeTypes: assignees.definitions,
       version: code.version,
       types: types.definitions,
       flows: flows.definitions,
       scope: scope.project == null ? { entityId: scope.entityId } : { entityId: scope.entityId, project: scope.project },
       revision: scope.revision ?? 0,
-      origins: { types: types.origins, flows: flows.origins },
-      retired: { types: types.retired, flows: flows.retired },
+      origins: { types: types.origins, flows: flows.origins, assigneeTypes: assignees.origins },
+      retired: { types: types.retired, flows: flows.retired, ...(assignees.retired.length > 0 ? { assigneeTypes: assignees.retired } : {}) },
     })
   }
 
@@ -189,19 +207,20 @@ export const createScopedSchemaHelper = (): ScopedSchemaHelper => {
       throw new PlanningUnsupported('schemas:read-only')
     }
     const originsOf = (kind: PlanningSchemaKind) =>
-      kind === PlanningSchemaKind.Type ? kept.origins?.types : kept.origins?.flows
+      kind === PlanningSchemaKind.AssigneeType ? kept.origins?.assigneeTypes : kind === PlanningSchemaKind.Type ? kept.origins?.types : kept.origins?.flows
     const retiredOf = (kind: PlanningSchemaKind) =>
-      kind === PlanningSchemaKind.Type ? kept.retired?.types : kept.retired?.flows
+      kind === PlanningSchemaKind.AssigneeType ? kept.retired?.assigneeTypes : kind === PlanningSchemaKind.Type ? kept.retired?.types : kept.retired?.flows
 
     return {
       ...base,
+      registerAssigneeType: refuse,
       registerType: refuse,
       registerFlow: refuse,
       load: refuse,
       scope: kept.scope ?? { entityId: '' },
       revision: kept.revision ?? 0,
       originOf: (kind, key) => originsOf(kind)?.[key]
-        ?? ((kind === PlanningSchemaKind.Type ? base.has(key) : base.flows().some(flow => flow.id === key))
+        ?? ((kind === PlanningSchemaKind.AssigneeType ? base.assigneeTypes().some(schema => schema.type === key) : kind === PlanningSchemaKind.Type ? base.has(key) : base.flows().some(flow => flow.id === key))
           ? SchemaOrigin.Code
           : undefined),
       isRetired: (kind, key) => retiredOf(kind)?.includes(key) === true,
@@ -218,7 +237,7 @@ export const createScopedSchemaHelper = (): ScopedSchemaHelper => {
   }
 
   return {
-    schemaRecordKey, schemaKeyOf, assertOverridable, assertFlowSchema, assertTypeSchema, resolveScopedBundle,
+    schemaRecordKey, schemaKeyOf, assertOverridable, assertAssigneeTypeSchema, assertFlowSchema, assertTypeSchema, resolveScopedBundle,
     scopedRegistryOf, flowInUse,
   }
 }
@@ -230,12 +249,12 @@ export const schemaRecordKey = (record: Pick<ScopedSchemaRecord, 'entityId' | 'p
   scopedSchemaHelper.schemaRecordKey(record)
 
 /** @deprecated compat:factory-refactor — use `scopedSchemaHelper.schemaKeyOf(…)` */
-export const schemaKeyOf = (kind: PlanningSchemaKind, definition: WorkcardTypeSchema | StatusFlowSchema): string =>
+export const schemaKeyOf = (kind: PlanningSchemaKind, definition: WorkcardTypeSchema | StatusFlowSchema | AssigneeTypeSchema): string =>
   scopedSchemaHelper.schemaKeyOf(kind, definition)
 
 /** @deprecated compat:factory-refactor — use `scopedSchemaHelper.assertOverridable(…)` */
 export const assertOverridable = (
-  code: Pick<PlanningSchemaRegistry, 'has' | 'type' | 'flows'>, kind: PlanningSchemaKind, key: string
+  code: Pick<PlanningSchemaRegistry, 'has' | 'type' | 'flows' | 'assigneeTypes'>, kind: PlanningSchemaKind, key: string
 ): void => scopedSchemaHelper.assertOverridable(code, kind, key)
 
 /** @deprecated compat:factory-refactor — use `scopedSchemaHelper.assertFlowSchema(…)` */

package/src/helpers/validate/types.ts

@@ -3,6 +3,7 @@ import type { PlanningSchemaRegistry, SpecificationSlot, Workcard } from '../../
 
 /** A record's shape, its type's `fields` and a document's body, checked against their schemas. */
 export interface ValidateHelper {
+  assertSchema: (schema: object, value: unknown) => void
   /** One line per ajv error: `/path message`. */
   ajvErrorText: (errors?: ErrorObject[] | null) => string
   /** Keys holding `.` or `$` at any depth — a document store cannot hold them. */

package/src/helpers/validate.ts

@@ -89,7 +89,12 @@ export const createValidateHelper = (): ValidateHelper => {
     }
   }
 
-  return { ajvErrorText, invalidFieldKeys, validateFields, validateCard, validateSpecificationBody }
+  const assertSchema = (schema: object, value: unknown): void => {
+    const validate = compile(schema)
+    if (!validate(value)) throw new FieldsInvalid(ajvErrorText(validate.errors))
+  }
+
+  return { assertSchema, ajvErrorText, invalidFieldKeys, validateFields, validateCard, validateSpecificationBody }
 }
 
 export const validateHelper = createValidateHelper()

package/src/helpers/wire.ts

@@ -225,7 +225,7 @@ export const createWireHelper = (): WireHelper => {
     ...encodeListOptions(query),
     from: encodeList(query?.from),
     to: encodeList(query?.to),
-    type: encodeList(query?.type),
+    type: encodeList(query?.type), fromKind: query?.fromKind, toKind: query?.toKind,
   })
 
   const decodeRelationshipQuery = (wire?: RelationshipQueryWire | RelationshipQuery | null): RelationshipQuery => {
@@ -235,6 +235,7 @@ export const createWireHelper = (): WireHelper => {
       from: decodeOneOrMany(value.from, 'from'),
       to: decodeOneOrMany(value.to, 'to'),
       type: decodeOneOrMany(value.type, 'type'),
+      fromKind: value.fromKind, toKind: value.toKind,
     }) as RelationshipQuery
   }
 

package/src/index.ts

@@ -11,3 +11,7 @@ export * from './registry.js'
 export * from './helpers/index.js'
 export * from './models/index.js'
 export * from './i18n.js'
+
+export type * from './resources/types.js'
+export * from './resources/mentions.js'
+export type * from './resources/protocol/types.js'

package/src/registry.ts

@@ -1,3 +1,4 @@
+import type { AssigneeTypeSchema } from './resources/types.js'
 import type { ValidateFunction } from 'ajv'
 import { PLANNING_SCHEMA_VERSION } from './consts.js'
 import { UnknownStatusFlow, UnknownWorkcardType } from './errors.js'
@@ -13,11 +14,31 @@ import type { AnyTypeSchema, PlanningSchemaBundle, PlanningSchemaRegistry, Statu
  */
 export const makeSchemaRegistry = (bundle?: Partial<PlanningSchemaBundle>): PlanningSchemaRegistry => {
   const types = new Map<string, AnyTypeSchema>()
+  const assigneeTypes = new Map<string, AssigneeTypeSchema>()
+  const assigneeValidators = new Map<string, ValidateFunction>()
   const flows = new Map<string, StatusFlowSchema>()
   const validators = new Map<string, ValidateFunction>()
   let ajv = makeAjv()
 
   const registry: PlanningSchemaRegistry = {
+    registerAssigneeType: schema => {
+      assigneeTypes.set(schema.type, schema)
+      assigneeValidators.delete(schema.type)
+    },
+    assigneeTypes: () => [...assigneeTypes.values()],
+    assigneeType: type => {
+      const schema = assigneeTypes.get(type)
+      if (schema == null) throw new UnknownWorkcardType(`assignee:${type}`)
+      return schema
+    },
+    assigneeValidator: type => {
+      let validator = assigneeValidators.get(type)
+      if (validator == null) {
+        validator = ajv.compile(registry.assigneeType(type).fields)
+        assigneeValidators.set(type, validator)
+      }
+      return validator
+    },
     registerType: schema => {
       types.set(schema.type, schema)
       validators.delete(schema.type)
@@ -70,19 +91,24 @@ export const makeSchemaRegistry = (bundle?: Partial<PlanningSchemaBundle>): Plan
       version: PLANNING_SCHEMA_VERSION,
       types: [...types.values()],
       flows: [...flows.values()],
+      assigneeTypes: [...assigneeTypes.values()],
     }),
 
     load: next => {
+      assigneeTypes.clear()
+      assigneeValidators.clear()
       types.clear()
       flows.clear()
       validators.clear()
       // A fresh ajv: a replaced type must not collide with a schema `$id` the old one compiled.
       ajv = makeAjv()
+      next.assigneeTypes?.forEach(registry.registerAssigneeType)
       next.flows.forEach(registry.registerFlow)
       next.types.forEach(registry.registerType)
     },
   }
 
+  bundle?.assigneeTypes?.forEach(registry.registerAssigneeType)
   bundle?.flows?.forEach(registry.registerFlow)
   bundle?.types?.forEach(registry.registerType)
 

package/src/resources/mentions.ts

@@ -0,0 +1,11 @@
+import type { MentionHelper } from './types.local.js'
+
+/** Stable-id Markdown mentions. Escaped display text cannot change the referenced identity. */
+export const mentionHelper: MentionHelper = {
+  encode: (id, nickname) => `[@${nickname.replace(/[\\\[\]]/g, '\\$&')}](assignee:${encodeURIComponent(id)})`,
+  parse: body => [...new Set([...body.matchAll(/\[@(?:\\.|[^\]\\])*\]\(assignee:([^\s)]+)\)/g)]
+    .flatMap(match => {
+      try { return [decodeURIComponent(match[1])] } catch { return [] }
+    }))],
+  nicknameKey: nickname => nickname.normalize('NFKC').trim().toLocaleLowerCase('en-US'),
+}

package/src/resources/protocol/types.ts

@@ -0,0 +1,20 @@
+import type { EntrypointProtocol } from '@owlmeans/entrypoint'
+import type { ListResult } from '@owlmeans/resource'
+import type { AssigneeDraft, TeamDraft, CommentDraft, PlanningRecord } from '../types.js'
+
+export interface PlanningResourceQueryWire { query?: string }
+export interface PlanningResourceCommand {
+  action: 'create' | 'update' | 'retire' | 'remove' | 'members' | 'projects' | 'assignees' | 'addMember' | 'removeMember' | 'attach' | 'detach' | 'rebuild'
+  id?: string
+  draft?: Partial<AssigneeDraft & TeamDraft & CommentDraft>
+  version?: number
+  assignee?: string
+  project?: string
+}
+export type PlanningResourceReply = PlanningRecord | PlanningRecord[] | string[] | null
+
+export interface PlanningResourceProtocols<R extends PlanningRecord = PlanningRecord> {
+  get: EntrypointProtocol<{ params: { id: string } }, R>
+  list: EntrypointProtocol<{ query: PlanningResourceQueryWire }, ListResult<R>>
+  write: EntrypointProtocol<{ body: PlanningResourceCommand }, PlanningResourceReply>
+}

package/src/resources/protocol.ts

@@ -0,0 +1,35 @@
+import { planningAliasHelper } from '../aliases.js'
+import { contract, protocol, typed } from '@owlmeans/entrypoint'
+import type { EntrypointProtocol } from '@owlmeans/entrypoint'
+import { backend, route, RouteMethod } from '@owlmeans/route'
+import { AssigneeKind } from '../consts.js'
+import { WorkcardParamsSchema } from '../schemas.js'
+import type { ListResult } from '@owlmeans/resource'
+import type { PlanningRecord } from './types.js'
+import type { PlanningResourceCommand, PlanningResourceProtocols, PlanningResourceQueryWire, PlanningResourceReply } from './protocol/types.js'
+
+/** Opt-in auxiliary branches share the planning base's authentication guards. */
+export const makePlanningResourceProtocols = <R extends PlanningRecord>(base: EntrypointProtocol<any, any>, alias: string, name: 'assignees' | 'teams' | 'comments' | 'mentions'): PlanningResourceProtocols<R> => {
+  const aliases = planningAliasHelper.planningResourceAliases(alias)[name]
+  const commandSchema = {
+    type: 'object', properties: {
+      action: { type: 'string', enum: ['create', 'update', 'retire', 'remove', 'members', 'projects', 'assignees', 'addMember', 'removeMember', 'attach', 'detach', 'rebuild'] },
+      id: { type: 'string', minLength: 1, maxLength: 128, nullable: true },
+      version: { type: 'number', minimum: 1, nullable: true },
+      assignee: { type: 'string', minLength: 1, maxLength: 128, nullable: true },
+      project: { type: 'string', minLength: 1, maxLength: 128, nullable: true },
+      draft: { type: 'object', properties: {
+        nickname: { type: 'string', nullable: true }, kind: { type: 'string', enum: [...Object.values(AssigneeKind), null], nullable: true },
+        type: { type: 'string', nullable: true }, name: { type: 'string', nullable: true }, externalId: { type: 'string', nullable: true },
+        card: { type: 'string', nullable: true }, body: { type: 'string', nullable: true },
+        fields: { type: 'object', additionalProperties: true, required: [], nullable: true },
+        authentication: { type: 'object', properties: { provider: { type: 'string' }, externalId: { type: 'string' } }, required: ['provider', 'externalId'], additionalProperties: false, nullable: true },
+      }, required: [], additionalProperties: false, nullable: true },
+    }, required: ['action'], additionalProperties: false,
+  }
+  return Object.freeze({
+    get: protocol(route(aliases.get, `/${name}/:id`, backend({ parent: base }, RouteMethod.GET)), contract.request({ params: typed<{ id: string }>(WorkcardParamsSchema) }, typed<R>())),
+    list: protocol(route(aliases.list, `/${name}`, backend({ parent: base }, RouteMethod.GET)), contract.request({ query: typed<PlanningResourceQueryWire>({ type: 'object', properties: { query: { type: 'string', maxLength: 16384, nullable: true } }, required: [], additionalProperties: false }) }, typed<ListResult<R>>())),
+    write: protocol(route(aliases.write, `/${name}`, backend({ parent: base }, RouteMethod.POST)), contract.request({ body: typed<PlanningResourceCommand>(commandSchema as any) }, typed<PlanningResourceReply>())),
+  })
+}

package/src/resources/types.local.ts

@@ -0,0 +1,5 @@
+export interface MentionHelper {
+  encode: (id: string, nickname: string) => string
+  parse: (body: string) => string[]
+  nicknameKey: (nickname: string) => string
+}

package/src/resources/types.ts

@@ -0,0 +1,148 @@
+import type { AnySchema, ValidateFunction } from 'ajv'
+import type { ListOptions, ListResult, ResourceRecord, Criteria } from '@owlmeans/resource'
+import type { AssigneeKind } from '../consts.js'
+
+/** Identity in an external authentication domain; neither email nor nickname is its key. */
+export interface AssigneeAuthentication {
+  provider: string
+  externalId: string
+}
+
+export interface AssigneeTypeSchema {
+  type: string
+  version: number
+  kind: AssigneeKind
+  fields: AnySchema
+  authentication?: 'required' | 'optional'
+  label?: string
+  overridable?: boolean
+}
+
+export interface PlanningRecord extends ResourceRecord {
+  id?: string
+  entityId: string
+  version: number
+  createdAt: string
+  updatedAt?: string
+}
+
+export interface Assignee extends PlanningRecord {
+  nickname: string
+  /** Organization-scoped, Unicode-normalized, case-insensitive identity key. */
+  nicknameKey: string
+  kind: AssigneeKind
+  type: string
+  fields: Record<string, unknown>
+  authentication?: AssigneeAuthentication
+  retired?: boolean
+}
+
+export interface Team extends PlanningRecord {
+  name: string
+  externalId?: string
+  fields: Record<string, unknown>
+}
+
+export interface Comment extends PlanningRecord {
+  card: string
+  /** Immutable author, resolved by the host from a trusted planning scope. */
+  author: string
+  body: string
+}
+
+/** A derived mention of a stable assignee id; revision is the source comment's version. */
+export interface CommentMention extends PlanningRecord {
+  comment: string
+  card: string
+  assignee: string
+  revision: number
+}
+
+export interface AssigneeDraft {
+  nickname: string
+  kind: AssigneeKind
+  type: string
+  fields?: Record<string, unknown>
+  authentication?: AssigneeAuthentication
+}
+
+export interface TeamDraft {
+  name: string
+  externalId?: string
+  fields?: Record<string, unknown>
+}
+
+export interface CommentDraft {
+  card: string
+  body: string
+}
+
+/** Compare-and-set version is mandatory for updates/removal, optional for retiring an assignee. */
+export interface PlanningWriteOptions { version: number }
+
+export interface AssigneeQuery extends ListOptions<Assignee> {
+  ids?: string[]
+  nickname?: string
+  kind?: AssigneeKind
+  type?: string
+  authentication?: AssigneeAuthentication
+  retired?: boolean
+}
+export interface TeamQuery extends ListOptions<Team> { ids?: string[], externalId?: string }
+export interface CommentQuery extends ListOptions<Comment> { card?: string, author?: string }
+export interface MentionQuery extends ListOptions<CommentMention> { comment?: string, card?: string, assignee?: string }
+
+/** Durable versioned resource port. put expects stored version + 1, with 1 for creation. */
+export interface PlanningRecordStore<R extends PlanningRecord> {
+  get: (id: string, entityId: string) => Promise<R | null>
+  list: (where: Criteria<R>, opts?: ListOptions<R>) => Promise<ListResult<R>>
+  put: (record: R) => Promise<R>
+  drop: (id: string, entityId: string, version: number) => Promise<void>
+}
+
+export interface PlanningResourceFacade {
+  assignees: {
+    get: (id: string) => Promise<Assignee>
+    load: (id: string) => Promise<Assignee | null>
+    list: (query?: AssigneeQuery) => Promise<ListResult<Assignee>>
+    create: (draft: AssigneeDraft) => Promise<Assignee>
+    update: (id: string, changes: Partial<AssigneeDraft>, opts: PlanningWriteOptions) => Promise<Assignee>
+    retire: (id: string, opts: PlanningWriteOptions) => Promise<Assignee>
+  }
+  teams: {
+    get: (id: string) => Promise<Team>
+    load: (id: string) => Promise<Team | null>
+    list: (query?: TeamQuery) => Promise<ListResult<Team>>
+    create: (draft: TeamDraft) => Promise<Team>
+    update: (id: string, changes: Partial<TeamDraft>, opts: PlanningWriteOptions) => Promise<Team>
+    remove: (id: string, opts: PlanningWriteOptions) => Promise<void>
+    members: (team: string) => Promise<Assignee[]>
+    addMember: (team: string, assignee: string) => Promise<void>
+    removeMember: (team: string, assignee: string) => Promise<void>
+    projects: (team: string) => Promise<string[]>
+    attach: (team: string, project: string) => Promise<void>
+    detach: (team: string, project: string) => Promise<void>
+    assignees: (project: string) => Promise<Assignee[]>
+  }
+  comments: {
+    get: (id: string) => Promise<Comment>
+    load: (id: string) => Promise<Comment | null>
+    list: (query?: CommentQuery) => Promise<ListResult<Comment>>
+    create: (draft: CommentDraft) => Promise<Comment>
+    update: (id: string, changes: Pick<CommentDraft, 'body'>, opts: PlanningWriteOptions) => Promise<Comment>
+    remove: (id: string, opts: PlanningWriteOptions) => Promise<void>
+  }
+  mentions: {
+    get: (id: string) => Promise<CommentMention>
+    load: (id: string) => Promise<CommentMention | null>
+    list: (query?: MentionQuery) => Promise<ListResult<CommentMention>>
+    rebuild: (comment: string) => Promise<CommentMention[]>
+  }
+}
+
+export interface AssigneeSchemaRegistry {
+  registerAssigneeType: (schema: AssigneeTypeSchema) => void
+  assigneeType: (type: string) => AssigneeTypeSchema
+  assigneeTypes: () => AssigneeTypeSchema[]
+  assigneeValidator: (type: string) => ValidateFunction
+}

package/src/schemas.ts

@@ -1,3 +1,5 @@
+import type { AssigneeTypeSchema, Assignee, Team, Comment, CommentMention } from './resources/types.js'
+import { AssigneeKind, PlanningResourceKind, ProjectMode } from './consts.js'
 import type { JSONSchemaType } from 'ajv'
 import { IdValueSchema } from '@owlmeans/auth'
 import { createListSchema } from '@owlmeans/resource'
@@ -68,6 +70,10 @@ const workcardProperties = {
   title: { type: 'string', minLength: 1, maxLength: TITLE_MAX },
   description: { type: 'string', maxLength: DESCRIPTION_MAX, nullable: true },
   parent: OptionalId,
+  parentType: { ...TypeKey, nullable: true },
+  reporter: OptionalId,
+  assignee: OptionalId,
+  mode: { type: 'string', enum: [...Object.values(ProjectMode), null], nullable: true },
   parents: { type: 'array', maxItems: MAX_PARENTS, items: Id },
   status: Label,
   intrinsic: IntrinsicStatusSchema,
@@ -101,7 +107,7 @@ const specificationProperties = {
 /** The optional form of a schema: `nullable`, and `null` admitted by an enum too. */
 const nullable = (schema: object): object => {
   const enumerated = (schema as { enum?: unknown[] }).enum
-  return { ...schema, nullable: true, ...(enumerated != null ? { enum: [...enumerated, null] } : {}) }
+  return { ...schema, nullable: true, ...(enumerated != null ? { enum: [...new Set([...enumerated, null])] } : {}) }
 }
 
 const nullableOf = (properties: Record<string, object>): Record<string, object> =>
@@ -135,6 +141,8 @@ export const RelationshipDraftSchema = cast<RelationshipDraft>({
     type: Label,
     from: OptionalId,
     to: Id,
+    fromKind: { type: 'string', enum: [...Object.values(PlanningResourceKind), null], nullable: true },
+    toKind: { type: 'string', enum: [...Object.values(PlanningResourceKind), null], nullable: true },
     fields: OptionalOpenObject,
   },
   required: ['type', 'to'],
@@ -149,6 +157,8 @@ export const RelationshipSchema = cast<Relationship>({
     type: Label,
     from: Id,
     to: Id,
+    fromKind: { type: 'string', enum: [...Object.values(PlanningResourceKind), null], nullable: true },
+    toKind: { type: 'string', enum: [...Object.values(PlanningResourceKind), null], nullable: true },
     project: OptionalId,
     fields: OptionalOpenObject,
     createdAt: IsoDate,
@@ -166,6 +176,10 @@ export const WorkcardChangesSchema = cast<WorkcardChanges>({
     title: workcardProperties.title,
     description: workcardProperties.description,
     parent: workcardProperties.parent,
+    parentType: workcardProperties.parentType,
+    reporter: workcardProperties.reporter,
+    assignee: workcardProperties.assignee,
+    mode: workcardProperties.mode,
     parents: workcardProperties.parents,
     status: workcardProperties.status,
     intrinsic: workcardProperties.intrinsic,
@@ -306,6 +320,10 @@ export const RelationshipTypeSchema = cast<RelationshipType>({
     name: Label,
     from: { type: 'array', items: TypeKey, nullable: true },
     to: { type: 'array', items: TypeKey, nullable: true },
+    fromKind: { type: 'string', enum: [...Object.values(PlanningResourceKind), null], nullable: true },
+    toKind: { type: 'string', enum: [...Object.values(PlanningResourceKind), null], nullable: true },
+    field: { ...TypeKey, nullable: true },
+    multiple: { type: 'boolean', nullable: true },
     inverse: { ...Label, nullable: true },
     single: { type: 'boolean', nullable: true },
     label: { type: 'string', maxLength: TITLE_MAX, nullable: true },
@@ -321,6 +339,8 @@ const typeProperties = {
   flows: { type: 'array', minItems: 1, items: TypeKey },
   intrinsic: nullable(IntrinsicPolicySchema),
   specifications: { type: 'array', items: SpecificationSlotSchema },
+  parents: { type: 'object', properties: { types: { type: 'array', items: TypeKey, nullable: true }, required: { type: 'boolean', nullable: true } }, required: [], additionalProperties: false, nullable: true },
+  children: { type: 'object', properties: { types: { type: 'array', items: TypeKey } }, required: ['types'], additionalProperties: false, nullable: true },
   relationships: { type: 'array', items: RelationshipTypeSchema, nullable: true },
   labels: { type: 'array', items: Label, nullable: true },
   code: { ...CodePolicySchema, nullable: true },
@@ -367,12 +387,43 @@ export const AnyTypeSchemaSchema = cast<AnyTypeSchema>({
   additionalProperties: false,
 })
 
+export const AssigneeTypeSchemaSchema = cast<AssigneeTypeSchema>({
+  type: 'object', properties: {
+    type: TypeKey, version: { type: 'number', minimum: 1 }, kind: { type: 'string', enum: Object.values(AssigneeKind) },
+    fields: OpenObject, authentication: { type: 'string', enum: ['required', 'optional', null], nullable: true },
+    label: { type: 'string', maxLength: TITLE_MAX, nullable: true }, overridable: { type: 'boolean', nullable: true },
+  }, required: ['type', 'version', 'kind', 'fields'], additionalProperties: false,
+})
+const planningRecordProperties = { id: OptionalId, entityId: Id, version: { type: 'number', minimum: 1 }, createdAt: IsoDate, updatedAt: OptionalIsoDate }
+const planningRecordRequired = ['entityId', 'version', 'createdAt']
+export const AssigneeSchema = cast<Assignee>({
+  type: 'object', properties: { ...planningRecordProperties,
+    nickname: { type: 'string', minLength: 1, maxLength: TYPE_MAX }, nicknameKey: TypeKey,
+    kind: { type: 'string', enum: Object.values(AssigneeKind) }, type: TypeKey, fields: OpenObject,
+    authentication: { type: 'object', properties: { provider: TypeKey, externalId: { type: 'string', minLength: 1, maxLength: REF_MAX } }, required: ['provider', 'externalId'], additionalProperties: false, nullable: true },
+    retired: { type: 'boolean', nullable: true },
+  }, required: [...planningRecordRequired, 'nickname', 'nicknameKey', 'kind', 'type', 'fields'], additionalProperties: false,
+})
+export const TeamSchema = cast<Team>({
+  type: 'object', properties: { ...planningRecordProperties, name: { type: 'string', minLength: 1, maxLength: TITLE_MAX }, externalId: { type: 'string', minLength: 1, maxLength: REF_MAX, nullable: true }, fields: OpenObject },
+  required: [...planningRecordRequired, 'name', 'fields'], additionalProperties: false,
+})
+export const CommentSchema = cast<Comment>({
+  type: 'object', properties: { ...planningRecordProperties, card: Id, author: Id, body: { type: 'string', minLength: 1, maxLength: BODY_MAX } },
+  required: [...planningRecordRequired, 'card', 'author', 'body'], additionalProperties: false,
+})
+export const CommentMentionSchema = cast<CommentMention>({
+  type: 'object', properties: { ...planningRecordProperties, comment: Id, card: Id, assignee: Id, revision: { type: 'number', minimum: 1 } },
+  required: [...planningRecordRequired, 'comment', 'card', 'assignee', 'revision'], additionalProperties: false,
+})
+
 export const PlanningSchemaBundleSchema = cast<PlanningSchemaBundle>({
   type: 'object',
   properties: {
     version: { type: 'number', minimum: 1 },
     types: { type: 'array', items: AnyTypeSchemaSchema },
     flows: { type: 'array', items: StatusFlowSchemaSchema },
+    assigneeTypes: { type: 'array', items: AssigneeTypeSchemaSchema, nullable: true },
   },
   required: ['version', 'types', 'flows'],
   additionalProperties: false,
@@ -421,6 +472,7 @@ export const ScopedSchemaBundleSchema = cast<ScopedSchemaBundle>({
     version: { type: 'number', minimum: 1 },
     types: { type: 'array', items: AnyTypeSchemaSchema },
     flows: { type: 'array', items: StatusFlowSchemaSchema },
+    assigneeTypes: { type: 'array', items: AssigneeTypeSchemaSchema, nullable: true },
     scope: {
       type: 'object',
       properties: { entityId: Id, project: OptionalId },
@@ -431,14 +483,14 @@ export const ScopedSchemaBundleSchema = cast<ScopedSchemaBundle>({
     revision: { type: 'number', minimum: 0, nullable: true },
     origins: {
       type: 'object',
-      properties: { types: originMap(), flows: originMap() },
+      properties: { types: originMap(), flows: originMap(), assigneeTypes: { ...originMap(), nullable: true } },
       required: ['types', 'flows'],
       additionalProperties: false,
       nullable: true,
     },
     retired: {
       type: 'object',
-      properties: { types: keyList(), flows: keyList() },
+      properties: { types: keyList(), flows: keyList(), assigneeTypes: { ...keyList(), nullable: true } },
       required: ['types', 'flows'],
       additionalProperties: false,
       nullable: true,
@@ -462,6 +514,7 @@ export const SchemaDefineRequestSchema = cast<SchemaDefineRequest>({
     mode: nullable(SchemaWriteModeSchema),
     types: { type: 'array', maxItems: MAX_QUERY_LIST, items: WorkcardTypeSchemaSchema, nullable: true },
     flows: { type: 'array', maxItems: MAX_QUERY_LIST, items: StatusFlowSchemaSchema, nullable: true },
+    assigneeTypes: { type: 'array', maxItems: MAX_QUERY_LIST, items: AssigneeTypeSchemaSchema, nullable: true },
     retire: { type: 'array', maxItems: MAX_QUERY_LIST, items: SchemaKeySchema, nullable: true },
   },
   required: [],
@@ -476,6 +529,9 @@ export const WorkcardDraftSchema = cast<WorkcardDraft>({
     kind: WorkcardKindSchema,
     type: TypeKey,
     parent: OptionalId,
+    reporter: OptionalId,
+    assignee: OptionalId,
+    mode: workcardProperties.mode,
     parents: { ...workcardProperties.parents, nullable: true },
     title: workcardProperties.title,
     description: workcardProperties.description,
@@ -673,6 +729,8 @@ export const SpecificationQuerySchema = cast<SpecificationQueryWire>({
 export const RelationshipQuerySchema = cast<RelationshipQueryWire>({
   type: 'object',
   properties: {
+    fromKind: { type: 'string', enum: [...Object.values(PlanningResourceKind), null], nullable: true },
+    toKind: { type: 'string', enum: [...Object.values(PlanningResourceKind), null], nullable: true },
     ...listWireProperties(),
     from: listValue(),
     to: listValue(),