@startsimpli/api 0.5.20 → 0.5.22

package/src/lib/workflows-api.ts

@@ -1,159 +1,205 @@
-/**
- * Workflows API wrapper
+/** Workflows API client — generic node-based workflow engine (epic startsim-xsh.11).
  *
- * Provides type-safe access to Django Workflows API
+ * Mirrors the other @startsimpli/api wrappers: an E-map of endpoints under
+ * `api/v1/workflows/`, the `client.fetch.{get,post,patch,delete}` convention,
+ * and the auto snake_case <-> camelCase transform (so all types here are
+ * camelCase).
+ *
+ * The execution detail type (`WorkflowExecutionDetail`) is deliberately shaped
+ * to match present-web's `run-to-builder-state.ts` `WorkflowRunDetail`, so a
+ * `getExecution(...)` response can be fed straight into `runToBuilderState`.
  */
 
+import type { PaginatedResponse } from '../types';
 import type { ApiClient } from './api-client';
 
-export type WorkflowStatus = 'draft' | 'active' | 'paused';
+const E = {
+  workflows: 'api/v1/workflows',
+  workflow: (id: string) => `api/v1/workflows/${id}`,
+  nodeTypes: 'api/v1/workflows/node-types',
+  execute: (id: string) => `api/v1/workflows/${id}/execute`,
+  executions: (id: string) => `api/v1/workflows/${id}/executions`,
+  execution: (executionId: string) => `api/v1/workflows/executions/${executionId}`,
+  cancel: (executionId: string) => `api/v1/workflows/executions/${executionId}/cancel`,
+  retry: (executionId: string) => `api/v1/workflows/executions/${executionId}/retry`,
+  clone: (id: string) => `api/v1/workflows/${id}/clone`,
+  publish: (id: string) => `api/v1/workflows/${id}/publish`,
+  versions: (id: string) => `api/v1/workflows/${id}/versions`,
+};
+
+/** Run lifecycle status — matches run-to-builder-state's `WorkflowRunStatus`. */
+export type RunStatus =
+  | 'pending'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'waiting';
+
+/** Per-node status — matches run-to-builder-state's `WorkflowNodeStatus`. */
+export type NodeStatus =
+  | 'idle'
+  | 'pending'
+  | 'running'
+  | 'success'
+  | 'error'
+  | 'skipped';
+
+export type ExecutionMode = 'manual' | 'trigger' | 'webhook';
+
+/** A node placed in a workflow graph (engine-defined shape). */
+export interface WorkflowNode {
+  id: string;
+  type: string;
+  parameters?: Record<string, unknown>;
+  position?: [number, number];
+  [key: string]: unknown;
+}
 
 export interface Workflow {
   id: string;
   name: string;
   description: string;
-  team: string;
-  createdBy: string | null;
-  nodes: any[];
-  connections: Record<string, any>;
-  settings: Record<string, any>;
-  staticData: Record<string, any>;
+  nodes: WorkflowNode[];
+  connections: Record<string, unknown>;
   isActive: boolean;
-  version: number;
-  isTemplate: boolean;
-  templateSource: string | null;
-  executionsCount: number;
-  createdAt: string;
-  updatedAt: string;
+  version?: number;
+  isTemplate?: boolean;
+  settings?: Record<string, unknown>;
+  executionsCount?: number;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+/** A registered node type the builder can place. */
+export interface NodeTypeDef {
+  slug: string;
+  category: string;
+  label: string;
+  /** JSON-schema-ish description of the node's parameters. */
+  parameterSchema: Record<string, unknown>;
+  /** Names of the node's output connectors. */
+  outputLabels: string[];
 }
 
+/** Lightweight execution summary (list rows). */
 export interface WorkflowExecution {
   id: string;
-  workflow: string;
-  workflowVersion: number;
-  triggeredBy: string;
-  status: 'pending' | 'running' | 'completed' | 'failed' | 'paused';
-  mode: 'manual' | 'trigger' | 'webhook';
-  contextData: Record<string, any>;
-  state: Record<string, any>;
+  workflowId: string;
+  status: RunStatus;
+  mode: ExecutionMode;
+  source?: string;
   startedAt: string | null;
   completedAt: string | null;
-  waitUntil: string | null;
-  errorMessage: string | null;
-  createdAt: string;
-  updatedAt: string;
 }
 
-export interface WorkflowFilters {
-  team?: string;
-  isActive?: boolean;
-  isTemplate?: boolean;
-  page?: number;
-  pageSize?: number;
-  ordering?: string;
+/** One node's execution record — matches run-to-builder-state's `RunNodeExecution`. */
+export interface WorkflowNodeExecution {
+  nodeId: string;
+  nodeName?: string;
+  nodeType?: string;
+  status: NodeStatus;
+  executionOrder?: number;
+  output?: Record<string, unknown> | null;
+}
+
+/** Full execution detail. Structurally matches present-web's `WorkflowRunDetail`
+ * so a response can be passed directly to `runToBuilderState`. */
+export interface WorkflowExecutionDetail {
+  status: RunStatus;
+  state: Record<string, unknown>;
+  nodeExecutions: WorkflowNodeExecution[];
+  contextData?: Record<string, unknown>;
 }
 
-export interface ExecuteWorkflowInput {
-  contextData?: Record<string, any>;
-  mode?: 'manual' | 'trigger' | 'webhook';
+/** The contract returned by POST execute/retry: carries the executionId. */
+export interface ExecuteWorkflowResponse {
+  executionId: string;
+  status: RunStatus;
 }
 
-export interface CreateWorkflowInput {
+export interface WorkflowInput {
   name: string;
   description?: string;
-  team: string;
-  nodes?: any[];
-  connections?: Record<string, any>;
-  settings?: Record<string, any>;
+  nodes?: WorkflowNode[];
+  connections?: Record<string, unknown>;
   isActive?: boolean;
+  settings?: Record<string, unknown>;
+}
+
+export interface WorkflowListParams {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  ordering?: string;
+  isActive?: boolean;
+  isTemplate?: boolean;
+  [key: string]: unknown;
+}
+
+export interface ExecutionListParams {
+  page?: number;
+  pageSize?: number;
+  status?: RunStatus;
+  ordering?: string;
+  [key: string]: unknown;
 }
 
 export class WorkflowsApi {
   constructor(private client: ApiClient) {}
 
-  /**
-   * List workflows with optional filters
-   */
-  async list(filters?: WorkflowFilters) {
-    const params = new URLSearchParams();
-
-    if (filters?.team) params.append('team', filters.team);
-    if (filters?.isActive !== undefined) params.append('isActive', String(filters.isActive));
-    if (filters?.isTemplate !== undefined) params.append('isTemplate', String(filters.isTemplate));
-    if (filters?.page) params.append('page', String(filters.page));
-    if (filters?.pageSize) params.append('pageSize', String(filters.pageSize));
-    if (filters?.ordering) params.append('ordering', filters.ordering);
-
-    return this.client.get<{ results: Workflow[]; count: number; next: string | null; previous: string | null }>(
-      `/api/v1/workflows/?${params.toString()}`
-    );
+  // --- Workflows ---
+  listWorkflows(params?: WorkflowListParams): Promise<PaginatedResponse<Workflow>> {
+    return this.client.fetch.get<PaginatedResponse<Workflow>>(E.workflows, { params });
   }
-
-  /**
-   * Get workflow by ID
-   */
-  async get(id: string) {
-    return this.client.get<Workflow>(`/api/v1/workflows/${id}/`);
+  getWorkflow(id: string): Promise<Workflow> {
+    return this.client.fetch.get<Workflow>(E.workflow(id));
   }
-
-  /**
-   * Create a new workflow
-   */
-  async create(data: CreateWorkflowInput) {
-    return this.client.post<Workflow>('/api/v1/workflows/', data);
+  createWorkflow(data: WorkflowInput): Promise<Workflow> {
+    return this.client.fetch.post<Workflow>(E.workflows, data);
   }
-
-  /**
-   * Update workflow
-   */
-  async update(id: string, data: Partial<CreateWorkflowInput>) {
-    return this.client.patch<Workflow>(`/api/v1/workflows/${id}/`, data);
+  updateWorkflow(id: string, data: Partial<WorkflowInput>): Promise<Workflow> {
+    return this.client.fetch.patch<Workflow>(E.workflow(id), data);
   }
-
-  /**
-   * Delete workflow
-   */
-  async delete(id: string) {
-    return this.client.delete(`/api/v1/workflows/${id}/`);
+  deleteWorkflow(id: string): Promise<void> {
+    return this.client.fetch.delete<void>(E.workflow(id));
   }
 
-  /**
-   * Execute workflow
-   */
-  async execute(id: string, input?: ExecuteWorkflowInput) {
-    return this.client.post<WorkflowExecution>(
-      `/api/v1/workflows/${id}/execute/`,
-      input || {}
-    );
+  // --- Node type registry ---
+  getNodeTypes(): Promise<NodeTypeDef[]> {
+    return this.client.fetch.get<NodeTypeDef[]>(E.nodeTypes);
   }
 
-  /**
-   * Get workflow templates
-   */
-  async templates() {
-    return this.client.get<Workflow[]>('/api/v1/workflows/templates/');
+  // --- Execution ---
+  /** Kick off a run. The response carries the executionId (the contract). */
+  executeWorkflow(id: string, contextData?: Record<string, unknown>): Promise<ExecuteWorkflowResponse> {
+    return this.client.fetch.post<ExecuteWorkflowResponse>(E.execute(id), { contextData });
   }
-
-  /**
-   * List workflow executions
-   */
-  async listExecutions(filters?: { workflow?: string; status?: string; page?: number; pageSize?: number }) {
-    const params = new URLSearchParams();
-
-    if (filters?.workflow) params.append('workflow', filters.workflow);
-    if (filters?.status) params.append('status', filters.status);
-    if (filters?.page) params.append('page', String(filters.page));
-    if (filters?.pageSize) params.append('pageSize', String(filters.pageSize));
-
-    return this.client.get<{ results: WorkflowExecution[]; count: number }>(
-      `/api/v1/workflow-executions/?${params.toString()}`
-    );
+  getExecution(executionId: string): Promise<WorkflowExecutionDetail> {
+    return this.client.fetch.get<WorkflowExecutionDetail>(E.execution(executionId));
+  }
+  listExecutions(
+    workflowId: string,
+    params?: ExecutionListParams,
+  ): Promise<PaginatedResponse<WorkflowExecution>> {
+    return this.client.fetch.get<PaginatedResponse<WorkflowExecution>>(E.executions(workflowId), { params });
+  }
+  cancelExecution(executionId: string): Promise<WorkflowExecution> {
+    return this.client.fetch.post<WorkflowExecution>(E.cancel(executionId), undefined);
+  }
+  /** Re-run a failed/cancelled execution; response carries the new executionId. */
+  retryExecution(executionId: string): Promise<ExecuteWorkflowResponse> {
+    return this.client.fetch.post<ExecuteWorkflowResponse>(E.retry(executionId), undefined);
   }
 
-  /**
-   * Get workflow execution details
-   */
-  async getExecution(id: string) {
-    return this.client.get<WorkflowExecution>(`/api/v1/workflow-executions/${id}/`);
+  // --- Lifecycle ---
+  cloneWorkflow(id: string): Promise<Workflow> {
+    return this.client.fetch.post<Workflow>(E.clone(id), undefined);
+  }
+  publishWorkflow(id: string): Promise<Workflow> {
+    return this.client.fetch.post<Workflow>(E.publish(id), undefined);
+  }
+  getVersions(id: string): Promise<Workflow[]> {
+    return this.client.fetch.get<Workflow[]>(E.versions(id));
   }
 }

package/src/types/index.ts

@@ -98,6 +98,28 @@ export type {
   ApolloEnrichmentSummary,
 } from './enrichment';
 
+// Team / Company / Invitation / Domain-claim types (startsim-o7s)
+export type {
+  Company,
+  AuthUserLike,
+  TeamRole,
+  Team,
+  TeamMember,
+  TeamInvitation,
+  DomainVerificationMethod,
+  EmailDomainClaim,
+  CompanyListParams,
+  UpdateCompanyInput,
+  TeamListParams,
+  BulkInviteEntry,
+  BulkInviteResult,
+  TeamInvitationListParams,
+  CreateTeamInvitationInput,
+  DomainClaimListParams,
+  CreateDomainClaimInput,
+  DomainVerifyEmailInitiateResponse,
+} from './team';
+
 // Error types
 export type {
   FieldError,

package/src/types/team.ts

@@ -0,0 +1,175 @@
+/**
+ * Team / Company / Invitation / Domain-claim types.
+ *
+ * Mirrors the Django serializers in apps.companies / apps.teams /
+ * apps.email_domain_claims. The FetchWrapper transforms snake_case ↔ camelCase
+ * at the boundary, so types here are camelCase. startsim-o7s.
+ */
+
+/** A Company is the top-level org tenant in StartSimpli. */
+export interface Company {
+  id: string;
+  slug: string;
+  name: string;
+  /** Free-form per-company settings blob (feature flags + product prefs). */
+  settings: Record<string, unknown>;
+  /** Hydrated by `?expand=owner`; otherwise just present as a foreign-key id. */
+  owner?: AuthUserLike | null;
+  ownerId?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * Trimmed AuthUser used by the team-mgmt serializers.
+ *
+ * Imported from @startsimpli/auth in practice, but we keep an internal shape
+ * here so @startsimpli/api stays decoupled from the auth package's exports.
+ * The real AuthUser is structurally compatible.
+ */
+export interface AuthUserLike {
+  id: string;
+  email: string;
+  firstName?: string;
+  lastName?: string;
+  fullName?: string;
+}
+
+/** Role hierarchy on a TeamMember (mirrors backend `Role` choices). */
+export type TeamRole = 'owner' | 'admin' | 'member' | 'viewer';
+
+/** A Team scopes role assignments inside a Company. */
+export interface Team {
+  id: string;
+  slug: string;
+  name: string;
+  companyId: string;
+  settings: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/** A TeamMember pins a user into a Team at a specific role. */
+export interface TeamMember {
+  id: string;
+  userId: string;
+  teamId: string;
+  role: TeamRole;
+  invitedById?: string | null;
+  joinedAt: string;
+  /** Optional hydrated user (when serializer expands it). */
+  user?: AuthUserLike;
+}
+
+/**
+ * Pending or accepted invitation to join a Team.
+ * `token` is write-only after create — surfaced only in the create response
+ * so apps can build accept-links.
+ */
+export interface TeamInvitation {
+  id: string;
+  email: string;
+  teamId: string;
+  role: TeamRole;
+  /** Only present in the create-response. Backend redacts on subsequent reads. */
+  token?: string;
+  invitedById: string;
+  expiresAt: string;
+  acceptedAt?: string | null;
+  revokedAt?: string | null;
+  isExpired: boolean;
+  isAccepted: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/** Verification method used for an EmailDomainClaim. */
+export type DomainVerificationMethod = 'dns_txt' | 'email_attestation';
+
+/**
+ * A Company's claim on an email domain — gates "anyone @acme.com auto-joins"
+ * behavior once verified. See startsim-gpu.
+ */
+export interface EmailDomainClaim {
+  id: string;
+  companyId: string;
+  domain: string;
+  verified: boolean;
+  verificationMethod?: DomainVerificationMethod | null;
+  /** Only visible to the creator on POST — otherwise null/absent. */
+  verificationToken?: string | null;
+  verifiedAt?: string | null;
+  verifiedById?: string | null;
+  lastVerifiedCheckAt?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+// ---- API request/payload shapes -------------------------------------------
+
+export interface CompanyListParams {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  ordering?: string;
+  [key: string]: unknown;
+}
+
+export interface UpdateCompanyInput {
+  name?: string;
+  slug?: string;
+  settings?: Record<string, unknown>;
+}
+
+export interface TeamListParams {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  companyId?: string;
+  ordering?: string;
+  [key: string]: unknown;
+}
+
+export interface BulkInviteEntry {
+  email: string;
+  role: TeamRole;
+}
+
+export interface BulkInviteResult {
+  invited: TeamInvitation[];
+  /** Backend may return duplicates / failures per the bulk endpoint. */
+  skipped?: Array<{ email: string; reason: string }>;
+}
+
+export interface TeamInvitationListParams {
+  page?: number;
+  pageSize?: number;
+  teamId?: string;
+  ordering?: string;
+  [key: string]: unknown;
+}
+
+export interface CreateTeamInvitationInput {
+  email: string;
+  teamId: string;
+  role: TeamRole;
+}
+
+export interface DomainClaimListParams {
+  page?: number;
+  pageSize?: number;
+  companyId?: string;
+  verified?: boolean;
+  ordering?: string;
+  [key: string]: unknown;
+}
+
+export interface CreateDomainClaimInput {
+  companyId: string;
+  domain: string;
+}
+
+export interface DomainVerifyEmailInitiateResponse {
+  /** Backend confirms an attestation email has been queued. */
+  detail: string;
+}

package/src/types/user.ts

@@ -24,9 +24,28 @@ export interface UpdateProfileRequest {
 export interface ChangePasswordRequest {
   oldPassword: string;
   newPassword: string;
-  newPasswordConfirm: string;
 }
 
 export interface ChangePasswordResponse {
   detail: string;
 }
+
+/**
+ * Passwordless early-access registration — name + email only.
+ * Hits POST /api/v1/auth/early-register/ (public, no auth).
+ */
+export interface EarlyRegisterRequest {
+  email: string;
+  firstName?: string;
+  lastName?: string;
+}
+
+export interface EarlyRegisterResponse {
+  user: {
+    id: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+  };
+  message: string;
+}