@critical-path/core 0.25.0 → 0.27.0

package/src/index.ts

@@ -5,4 +5,5 @@ export * from './storage/index.js';
 export * from './plugins/index.js';
 export * from './engine/index.js';
 export * from './domain/index.js';
+export * from './webhooks/index.js';
 

package/src/schemas/index.ts

@@ -10,6 +10,7 @@
  */
 import { z } from 'zod';
 import { ValidationError, type ValidationIssue } from '../domain/errors.js';
+import { DOMAIN_EVENT_NAMES } from '../domain/events.js';
 
 /**
  * Parses `data` with `schema`, returning the cleaned value (unknown keys stripped, defaults
@@ -111,7 +112,9 @@ export const CreateProjectSchema = strictObject({
   name: nonEmpty,
   description: z.string().optional(),
   ownerId: z.string().optional(),
-  members: z.array(z.string()).optional(),
+  members: z
+    .array(strictObject({ userId: nonEmpty, role: z.enum(['admin', 'project_manager', 'contributor', 'viewer']) }))
+    .optional(),
   teamIds: z.array(z.string()).optional(),
   workflowId: z.string().optional(),
   taskTypes: z.array(TaskTypeDefinitionSchema).optional(),
@@ -303,6 +306,8 @@ export const UploadAttachmentSchema = strictObject({
 });
 
 export const PresignAttachmentSchema = strictObject({
+  /** Project the upload belongs to; scoped callers may only write under `projects/<projectId>/`. */
+  projectId: nonEmpty,
   storageKey: nonEmpty,
   expiresInSeconds: z.number().int().positive().optional(),
   contentType: z.string().optional()
@@ -318,6 +323,20 @@ export const LogTimeSchema = strictObject({
   loggedAt: isoString.optional()
 });
 
+// --- Webhooks ---
+
+export const CreateWebhookSchema = strictObject({
+  name: nonEmpty,
+  /** http(s) URL; private and local addresses are rejected unless the engine allows them. */
+  url: nonEmpty,
+  /** Domain event names (e.g. `task.created`) or `'*'` for all events. */
+  events: z.array(z.enum(['*', ...DOMAIN_EVENT_NAMES])).min(1),
+  /** Signing secret (at least 16 characters). Generated when omitted and returned once. */
+  secret: z.string().min(16).optional(),
+  active: z.boolean().optional()
+});
+export const UpdateWebhookSchema = CreateWebhookSchema.partial();
+
 export type CreateTaskPayload = z.infer<typeof CreateTaskSchema>;
 export type UpdateTaskPayload = z.infer<typeof UpdateTaskSchema>;
 export type CreateProjectPayload = z.infer<typeof CreateProjectSchema>;
@@ -346,4 +365,6 @@ export type CreateAttachmentBody = z.input<typeof CreateAttachmentSchema>;
 export type UploadAttachmentBody = z.input<typeof UploadAttachmentSchema>;
 export type PresignAttachmentBody = z.input<typeof PresignAttachmentSchema>;
 export type LogTimeBody = z.input<typeof LogTimeSchema>;
+export type CreateWebhookBody = z.input<typeof CreateWebhookSchema>;
+export type UpdateWebhookBody = z.input<typeof UpdateWebhookSchema>;
 

package/src/schemas/schemas.test.ts

@@ -13,7 +13,8 @@ import type {
   Iteration,
   Comment,
   CreateAttachmentInput,
-  TimeEntry
+  TimeEntry,
+  Webhook
 } from '../types/index.js';
 import {
   CreateTaskSchema,
@@ -30,7 +31,8 @@ import {
   CreateCommentSchema,
   UpdateCommentSchema,
   CreateAttachmentSchema,
-  LogTimeSchema
+  LogTimeSchema,
+  CreateWebhookSchema
 } from './index.js';
 
 /**
@@ -46,7 +48,8 @@ type SameKeys<Schema, Expected> = [Exclude<keyof Schema, keyof Expected>, Exclud
   : { extraInSchema: Exclude<keyof Schema, keyof Expected>; missingFromSchema: Exclude<keyof Expected, keyof Schema> };
 
 type Infer<S extends z.ZodTypeAny> = z.infer<S>;
-type ServerAssigned = 'id' | 'createdAt' | 'updatedAt';
+// tenantId is stamped from the actor by the engine, never accepted from payloads.
+type ServerAssigned = 'id' | 'createdAt' | 'updatedAt' | 'tenantId';
 // Identity is resolved by the server (withActor), never accepted in payloads.
 type CommentIdentity = 'authorId' | 'authorType';
 type UploaderIdentity = 'uploaderId' | 'uploaderType';
@@ -55,7 +58,7 @@ const keyChecks: true[] = [
   true as SameKeys<Infer<typeof CreateTaskSchema>, Omit<CreateTaskInput, 'key'>>,
   true as SameKeys<Infer<typeof UpdateTaskSchema>, Omit<Task, ServerAssigned | 'key' | 'projectId'>>,
   // `workflow` is a denormalised copy resolved from `workflowId`, so it is not writable.
-  true as SameKeys<Infer<typeof CreateProjectSchema>, Omit<CreateProjectInput, 'workflow'>>,
+  true as SameKeys<Infer<typeof CreateProjectSchema>, Omit<CreateProjectInput, 'workflow' | 'tenantId'>>,
   true as SameKeys<Infer<typeof UpdateProjectSchema>, Omit<Project, ServerAssigned | 'workflow'>>,
   true as SameKeys<Infer<typeof CreateWorkflowSchema>, Omit<Workflow, ServerAssigned>>,
   true as SameKeys<Infer<typeof CreateDeliverableSchema>, CreateDeliverableInput>,
@@ -68,7 +71,8 @@ const keyChecks: true[] = [
   true as SameKeys<Infer<typeof CreateCommentSchema>, Omit<Comment, ServerAssigned | 'reactions' | CommentIdentity>>,
   true as SameKeys<Infer<typeof UpdateCommentSchema>, Pick<Comment, 'content' | 'mentions' | 'metadata'>>,
   true as SameKeys<Infer<typeof CreateAttachmentSchema>, Omit<CreateAttachmentInput, UploaderIdentity>>,
-  true as SameKeys<Infer<typeof LogTimeSchema>, Omit<TimeEntry, 'id' | 'userId'>>
+  true as SameKeys<Infer<typeof LogTimeSchema>, Omit<TimeEntry, 'id' | 'userId'>>,
+  true as SameKeys<Infer<typeof CreateWebhookSchema>, Pick<Webhook, 'name' | 'url' | 'events' | 'secret' | 'active'>>
 ];
 
 describe('request schemas', () => {

package/src/store/firebase.test.ts

@@ -107,5 +107,25 @@ describe('FirebaseStore', () => {
     expect(byUpstream).toHaveLength(1);
     expect(byUpstream[0].id).toBe(dep.id);
   });
+
+  it('should create, update, clear fields on, and delete webhooks', async () => {
+    const created = await store.addWebhook({
+      name: 'Hook',
+      url: 'https://hooks.example.com/x',
+      events: ['task.created'],
+      secret: 'whsec_test',
+      active: true,
+      tenantId: 'acme'
+    });
+    expect(await store.getWebhook(created.id)).toMatchObject({ name: 'Hook', tenantId: 'acme' });
+
+    const updated = await store.updateWebhook(created.id, { events: ['*'], secret: undefined });
+    expect(updated?.events).toEqual(['*']);
+    expect((await store.getWebhook(created.id))?.secret).toBeUndefined();
+
+    expect(await store.deleteWebhook(created.id)).toBe(true);
+    expect(await store.getWebhook(created.id)).toBeNull();
+    expect(await store.deleteWebhook(created.id)).toBe(false);
+  });
 });
 

package/src/store/firebase.ts

@@ -573,6 +573,11 @@ export class FirebaseStore implements StorageAdapter {
     return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
   }
 
+  async getWebhook(id: string): Promise<Webhook | null> {
+    const doc = await this.db.collection('webhooks').doc(id).get();
+    return doc.exists ? ({ ...doc.data(), id: doc.id } as Webhook) : null;
+  }
+
   async addWebhook(webhook: Omit<Webhook, 'id' | 'createdAt'>): Promise<Webhook> {
     const docRef = this.db.collection('webhooks').doc();
     const now = new Date().toISOString();
@@ -580,4 +585,21 @@ export class FirebaseStore implements StorageAdapter {
     await docRef.set(sanitizeFirestoreData(newWh));
     return newWh;
   }
+
+  async updateWebhook(id: string, updates: Partial<Omit<Webhook, 'id' | 'createdAt'>>): Promise<Webhook | null> {
+    const existing = await this.getWebhook(id);
+    if (!existing) return null;
+    const updated: Webhook = { ...existing, ...updates, id, createdAt: existing.createdAt };
+    // Write the whole document (no merge) so fields cleared with `undefined` are removed.
+    await this.db.collection('webhooks').doc(id).set(sanitizeFirestoreData(updated));
+    return updated;
+  }
+
+  async deleteWebhook(id: string): Promise<boolean> {
+    const ref = this.db.collection('webhooks').doc(id);
+    const doc = await ref.get();
+    if (!doc.exists) return false;
+    await ref.delete();
+    return true;
+  }
 }

package/src/store/index.ts

@@ -101,7 +101,10 @@ export interface DependencyRepository {
 
 export interface WebhookRepository {
   getWebhooks(): Promise<Webhook[]>;
+  getWebhook(id: string): Promise<Webhook | null>;
   addWebhook(webhook: Omit<Webhook, 'id' | 'createdAt'>): Promise<Webhook>;
+  updateWebhook(id: string, updates: Partial<Omit<Webhook, 'id' | 'createdAt'>>): Promise<Webhook | null>;
+  deleteWebhook(id: string): Promise<boolean>;
 }
 
 export interface DeliverableRepository {
@@ -538,10 +541,26 @@ export class InMemoryStore implements StorageAdapter {
     return Array.from(this.webhooks.values());
   }
 
+  async getWebhook(id: string): Promise<Webhook | null> {
+    return this.webhooks.get(id) ?? null;
+  }
+
   async addWebhook(webhook: Omit<Webhook, 'id' | 'createdAt'>): Promise<Webhook> {
     const id = `wh_${Math.random().toString(36).substring(2, 9)}`;
     const newWh: Webhook = { ...webhook, id, createdAt: new Date().toISOString() };
     this.webhooks.set(id, newWh);
     return newWh;
   }
+
+  async updateWebhook(id: string, updates: Partial<Omit<Webhook, 'id' | 'createdAt'>>): Promise<Webhook | null> {
+    const existing = this.webhooks.get(id);
+    if (!existing) return null;
+    const updated: Webhook = { ...existing, ...updates, id, createdAt: existing.createdAt };
+    this.webhooks.set(id, updated);
+    return updated;
+  }
+
+  async deleteWebhook(id: string): Promise<boolean> {
+    return this.webhooks.delete(id);
+  }
 }

package/src/store/sqlite.ts

@@ -279,6 +279,22 @@ export class SQLiteStore implements StorageAdapter {
     } catch {
       // Column may already exist
     }
+
+    for (const column of ['name TEXT', 'tenantId TEXT']) {
+      try {
+        this.db.exec(`ALTER TABLE webhooks ADD COLUMN ${column}`);
+      } catch {
+        // Column may already exist
+      }
+    }
+
+    for (const table of ['projects', 'workflows', 'teams']) {
+      try {
+        this.db.exec(`ALTER TABLE ${table} ADD COLUMN tenantId TEXT`);
+      } catch {
+        // Column may already exist
+      }
+    }
   }
 
   // --- Projects ---
@@ -301,8 +317,8 @@ export class SQLiteStore implements StorageAdapter {
     const newProj: Project = { ...project, key, id, createdAt: now, updatedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO projects (id, key, name, description, ownerId, members, teamIds, workflowId, taskTypes, statusDefinitions, priorityDefinitions, customFieldDefinitions, createdAt, updatedAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO projects (id, key, name, description, ownerId, members, teamIds, workflowId, taskTypes, statusDefinitions, priorityDefinitions, customFieldDefinitions, tenantId, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newProj.id,
@@ -317,6 +333,7 @@ export class SQLiteStore implements StorageAdapter {
       JSON.stringify(newProj.statusDefinitions || []),
       JSON.stringify(newProj.priorityDefinitions || []),
       JSON.stringify(newProj.customFieldDefinitions || []),
+      newProj.tenantId ?? null,
       newProj.createdAt,
       newProj.updatedAt
     );
@@ -375,8 +392,8 @@ export class SQLiteStore implements StorageAdapter {
     const newWf: Workflow = { ...workflow, id, createdAt: now, updatedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO workflows (id, name, description, statuses, transitions, taskTypes, defaultStatusKey, isDefault, createdAt, updatedAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO workflows (id, name, description, statuses, transitions, taskTypes, defaultStatusKey, isDefault, tenantId, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newWf.id,
@@ -387,6 +404,7 @@ export class SQLiteStore implements StorageAdapter {
       newWf.taskTypes ? JSON.stringify(newWf.taskTypes) : null,
       newWf.defaultStatusKey || null,
       newWf.isDefault ? 1 : 0,
+      newWf.tenantId ?? null,
       newWf.createdAt,
       newWf.updatedAt
     );
@@ -452,8 +470,8 @@ export class SQLiteStore implements StorageAdapter {
     const newTeam: Team = { ...team, id, createdAt: now, updatedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO teams (id, name, description, leaderId, memberIds, createdAt, updatedAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO teams (id, name, description, leaderId, memberIds, tenantId, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newTeam.id,
@@ -461,6 +479,7 @@ export class SQLiteStore implements StorageAdapter {
       newTeam.description || null,
       newTeam.leaderId || null,
       JSON.stringify(newTeam.memberIds || []),
+      newTeam.tenantId ?? null,
       newTeam.createdAt,
       newTeam.updatedAt
     );
@@ -1164,11 +1183,48 @@ export class SQLiteStore implements StorageAdapter {
   async getWebhooks(): Promise<Webhook[]> {
     const stmt = this.db.prepare('SELECT * FROM webhooks');
     const rows = stmt.all() as any[];
-    return rows.map((r) => ({
-      ...r,
-      events: JSON.parse(r.events),
-      active: Boolean(r.active)
-    }));
+    return rows.map((r) => this.mapWebhook(r));
+  }
+
+  async getWebhook(id: string): Promise<Webhook | null> {
+    const row = this.db.prepare('SELECT * FROM webhooks WHERE id = ?').get(id) as any;
+    return row ? this.mapWebhook(row) : null;
+  }
+
+  async updateWebhook(id: string, updates: Partial<Omit<Webhook, 'id' | 'createdAt'>>): Promise<Webhook | null> {
+    const existing = await this.getWebhook(id);
+    if (!existing) return null;
+    const updated: Webhook = { ...existing, ...updates, id, createdAt: existing.createdAt };
+    this.db
+      .prepare('UPDATE webhooks SET name = ?, url = ?, events = ?, secret = ?, active = ?, tenantId = ? WHERE id = ?')
+      .run(
+        updated.name ?? null,
+        updated.url,
+        JSON.stringify(updated.events),
+        updated.secret ?? null,
+        updated.active ? 1 : 0,
+        updated.tenantId ?? null,
+        id
+      );
+    return updated;
+  }
+
+  async deleteWebhook(id: string): Promise<boolean> {
+    const result = this.db.prepare('DELETE FROM webhooks WHERE id = ?').run(id);
+    return Number(result.changes) > 0;
+  }
+
+  private mapWebhook(row: any): Webhook {
+    return {
+      id: row.id,
+      name: row.name ?? '',
+      url: row.url,
+      events: JSON.parse(row.events),
+      secret: row.secret ?? undefined,
+      active: Boolean(row.active),
+      tenantId: row.tenantId ?? undefined,
+      createdAt: row.createdAt
+    };
   }
 
   async addWebhook(webhook: Omit<Webhook, 'id' | 'createdAt'>): Promise<Webhook> {
@@ -1177,15 +1233,17 @@ export class SQLiteStore implements StorageAdapter {
     const newWh: Webhook = { ...webhook, id, createdAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO webhooks (id, url, events, secret, active, createdAt)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO webhooks (id, name, url, events, secret, active, tenantId, createdAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newWh.id,
+      newWh.name ?? null,
       newWh.url,
       JSON.stringify(newWh.events),
       newWh.secret || null,
       newWh.active ? 1 : 0,
+      newWh.tenantId ?? null,
       newWh.createdAt
     );
     return newWh;
@@ -1195,6 +1253,7 @@ export class SQLiteStore implements StorageAdapter {
   private mapProject(row: any): Project {
     return {
       ...row,
+      tenantId: row.tenantId ?? undefined,
       workflowId: row.workflowId || undefined,
       taskTypes: row.taskTypes ? JSON.parse(row.taskTypes) : undefined,
       members: row.members ? JSON.parse(row.members) : [],
@@ -1208,6 +1267,7 @@ export class SQLiteStore implements StorageAdapter {
   private mapWorkflow(row: any): Workflow {
     return {
       ...row,
+      tenantId: row.tenantId ?? undefined,
       statuses: row.statuses ? JSON.parse(row.statuses) : [],
       transitions: row.transitions ? JSON.parse(row.transitions) : [],
       taskTypes: row.taskTypes ? JSON.parse(row.taskTypes) : undefined,
@@ -1218,6 +1278,7 @@ export class SQLiteStore implements StorageAdapter {
   private mapTeam(row: any): Team {
     return {
       ...row,
+      tenantId: row.tenantId ?? undefined,
       memberIds: row.memberIds ? JSON.parse(row.memberIds) : []
     };
   }

package/src/types/index.ts

@@ -78,6 +78,8 @@ export interface Team {
   memberIds: string[];
   weeklyCapacityHours?: number;
   schedule?: WorkSchedule;
+  /** Tenant that owns the team. Set by the engine from the creating actor. */
+  tenantId?: string;
   createdAt: string;
   updatedAt: string;
 }
@@ -117,6 +119,8 @@ export interface Workflow {
   taskTypes?: TaskTypeDefinition[];
   defaultStatusKey?: string;
   isDefault?: boolean;
+  /** Tenant that owns the workflow. Set by the engine from the creating actor. */
+  tenantId?: string;
   createdAt: string;
   updatedAt: string;
 }
@@ -127,7 +131,10 @@ export interface Project {
   name: string;
   description?: string;
   ownerId?: string;
-  members?: string[]; // user IDs
+  /** Project membership and roles, used by role-based authorization policies. */
+  members?: ProjectMember[];
+  /** Tenant that owns the project. Set by the engine from the creating actor; never from payloads. */
+  tenantId?: string;
   teamIds?: string[]; // team IDs
   workflowId?: string;
   workflow?: Workflow;
@@ -305,6 +312,21 @@ export interface Actor {
   userId: string;
   username?: string;
   actorType?: AuthorType;
+  /**
+   * Tenant the actor belongs to. When set, the actor only sees projects, workflows and teams
+   * with the same `tenantId`, and everything it creates is stamped with it.
+   */
+  tenantId?: string;
+  /** Workspace-wide roles, e.g. `['admin']`. Interpreted by the authorization policy. */
+  roles?: string[];
+}
+
+/** A user's role on a project. */
+export type ProjectRole = Role;
+
+export interface ProjectMember {
+  userId: string;
+  role: ProjectRole;
 }
 
 export interface CommentReaction {
@@ -407,40 +429,24 @@ export interface Webhook {
   id: string;
   name: string;
   url: string;
+  /** HMAC-SHA256 signing secret. Never returned by engine reads (see `PublicWebhook`). */
   secret?: string;
+  /** Event names to deliver, or `'*'` for every event. */
   events: WebhookEvent[];
   active: boolean;
+  /** Tenant whose events this webhook receives. Set from the creating actor. */
+  tenantId?: string;
   createdAt: string;
 }
 
-export type WebhookEvent =
-  | 'project.created'
-  | 'project.updated'
-  | 'project.deleted'
-  | 'task.created'
-  | 'task.updated'
-  | 'task.deleted'
-  | 'task.status_changed'
-  | 'task.blocked'
-  | 'task.unblocked'
-  | 'comment.created'
-  | 'comment.updated'
-  | 'comment.deleted'
-  | 'comment.reaction.added'
-  | 'comment.reaction.removed'
-  | 'attachment.created'
-  | 'attachment.deleted'
-  | 'iteration.started'
-  | 'iteration.completed'
-  | 'team.created'
-  | 'container.created'
-  | 'workflow.created'
-  | 'workflow.updated'
-  | 'workflow.deleted'
-  | 'deliverable.created'
-  | 'deliverable.updated'
-  | 'deliverable.deleted'
-  | 'deliverable.status_changed';
+/** A webhook as returned by engine and API reads: the secret is replaced by `hasSecret`. */
+export type PublicWebhook = Omit<Webhook, 'secret'> & { hasSecret: boolean };
+
+/**
+ * Webhook subscriptions use domain event names (e.g. `task.created`, `time.logged`); see
+ * `CriticalPathDomainEvent` in `domain/events.ts`. `'*'` subscribes to everything.
+ */
+export type WebhookEvent = import('../domain/events.js').CriticalPathDomainEvent['name'] | '*';
 
 export interface PluginHooks {
   beforeTaskCreate?: (task: Partial<Task>) => Promise<Partial<Task>> | Partial<Task>;
@@ -462,10 +468,20 @@ export interface CriticalPathPlugin {
 }
 
 export interface CriticalPathConfig {
+  /**
+   * Authorization policy applied to every call made through a `withActor` view (which is how
+   * `@critical-path/server` and the MCP server call the engine). Calls on the base engine are
+   * trusted. Use `createRolePolicy()` for project-membership roles, or supply your own.
+   * When omitted, actors may do anything within their tenant.
+   */
+  authorize?: AuthorizationPolicy;
   store?: 'memory' | 'sqlite' | unknown;
   fileStorage?: FileStorageAdapter;
   plugins?: CriticalPathPlugin[];
+  /** Static webhooks (not stored or editable through the API). */
   webhooks?: Omit<Webhook, 'id' | 'createdAt'>[];
+  /** Delivery behaviour: queue, timeouts, retries, private URL policy, failure callbacks. */
+  webhookDelivery?: import('../webhooks/dispatcher.js').WebhookDeliveryOptions;
   defaultSchedule?: WorkSchedule;
   initialData?: {
     projects?: Project[];
@@ -742,3 +758,39 @@ export interface WorkloadDistributionOptions {
   teamSchedules?: Record<string, WorkSchedule>;
 }
 
+// ==========================================
+// Authorization
+// ==========================================
+
+/**
+ * Operations the engine authorizes. Project-scoped actions are checked against a project;
+ * `project.create` and `workspace.manage` (workflows, teams, webhooks) are workspace-level.
+ */
+export type AuthorizationAction =
+  | 'project.read'
+  | 'project.create'
+  | 'project.update'
+  | 'project.delete'
+  | 'project.manage_members'
+  | 'task.create'
+  | 'task.update'
+  | 'task.delete'
+  | 'comment.create'
+  | 'comment.moderate'
+  | 'attachment.create'
+  | 'attachment.delete'
+  | 'time.log'
+  | 'plan.manage'
+  | 'workspace.manage';
+
+export interface AuthorizationRequest {
+  actor: Actor;
+  action: AuthorizationAction;
+  /** The project the action targets, for project-scoped actions. */
+  project?: Project;
+  /** The specific record, when relevant (e.g. the comment being edited). */
+  resource?: { type: 'task' | 'comment' | 'attachment'; ownerId?: string };
+}
+
+export type AuthorizationPolicy = (request: AuthorizationRequest) => boolean | Promise<boolean>;
+