@startsimpli/api 0.5.20 → 0.5.22

package/src/lib/presentations-api.ts

@@ -0,0 +1,166 @@
+/** Presentations API client — AI-generated slide decks (epic startsim-3ks).
+
+Mirrors the other @startsimpli/api wrappers and the proven n8n "Slide Deck
+Agent v9" pipeline: a deck has ONE derived style spec applied verbatim to every
+slide; each slide is a full-bleed 16:9 image (image render mode), compiled into
+PPTX + PDF. The client auto-transforms snake_case <-> camelCase, so types here
+are camelCase.
+*/
+
+import type { PaginatedResponse } from '../types';
+import type { ApiClient } from './api-client';
+
+const E = {
+  decks: 'api/v1/presentations/decks',
+  deck: (id: string) => `api/v1/presentations/decks/${id}`,
+  generate: (id: string) => `api/v1/presentations/decks/${id}/generate`,
+  compile: (id: string) => `api/v1/presentations/decks/${id}/compile`,
+  status: (id: string) => `api/v1/presentations/decks/${id}/status`,
+  slides: (id: string) => `api/v1/presentations/decks/${id}/slides`,
+  slide: (id: string, n: number) => `api/v1/presentations/decks/${id}/slides/${n}`,
+  regenerate: (id: string, n: number) => `api/v1/presentations/decks/${id}/slides/${n}/regenerate`,
+  reorder: (id: string) => `api/v1/presentations/decks/${id}/slides/reorder`,
+};
+
+export type DeckStatus = 'draft' | 'generating' | 'ready' | 'error';
+export type SlideStatus = 'pending' | 'generating' | 'ready' | 'error';
+export type RenderMode = 'image' | 'structured';
+
+export interface Slide {
+  id: string;
+  deckId: string;
+  slideNumber: number;
+  title?: string;
+  /** Raw text content / outline for this slide. */
+  content: string;
+  /** The full image-generation prompt (style spec + slide content). */
+  imagePrompt?: string;
+  /** Full-bleed slide image (image render mode). */
+  imageUrl?: string;
+  status: SlideStatus;
+  renderMode: RenderMode;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface Deck {
+  id: string;
+  title: string;
+  /** Pasted outline the deck was generated from. */
+  outline: string;
+  /** Free-text audience / context that informs the style spec. */
+  audience: string;
+  /** The single derived STYLE SPEC, reused verbatim on every slide. */
+  styleSpec: string;
+  status: DeckStatus;
+  renderMode: RenderMode;
+  slideCount: number;
+  /** Compiled artifacts (present once compiled). */
+  pptxUrl?: string | null;
+  pdfUrl?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  /** Present on detail responses. */
+  slides?: Slide[];
+}
+
+export interface DeckInput {
+  title: string;
+  outline?: string;
+  audience?: string;
+  renderMode?: RenderMode;
+}
+
+export interface GenerateDeckInput {
+  /** Outline to (re)generate from; defaults to the deck's stored outline. */
+  outline?: string;
+  /** Optional explicit style spec; otherwise the backend derives one. */
+  styleSpec?: string;
+}
+
+export interface SlideInput {
+  title?: string;
+  content?: string;
+  imagePrompt?: string;
+}
+
+export interface RegenerateSlideInput {
+  /** Revised content for the slide. */
+  content?: string;
+  /** Natural-language change request ("make it punchier"). */
+  instruction?: string;
+}
+
+/** Lightweight per-slide progress for polling during generation. */
+export interface DeckGenerationStatus {
+  status: DeckStatus;
+  slides: Array<{
+    slideNumber: number;
+    status: SlideStatus;
+    imageUrl?: string;
+  }>;
+}
+
+export interface CompileResult {
+  status: DeckStatus;
+  pptxUrl: string;
+  pdfUrl: string;
+}
+
+export interface DeckListParams {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  ordering?: string;
+  [key: string]: unknown;
+}
+
+export class PresentationsApi {
+  constructor(private client: ApiClient) {}
+
+  // --- Decks ---
+  listDecks(params?: DeckListParams): Promise<PaginatedResponse<Deck>> {
+    return this.client.fetch.get<PaginatedResponse<Deck>>(E.decks, { params });
+  }
+  getDeck(id: string): Promise<Deck> {
+    return this.client.fetch.get<Deck>(E.deck(id));
+  }
+  createDeck(data: DeckInput): Promise<Deck> {
+    return this.client.fetch.post<Deck>(E.decks, data);
+  }
+  updateDeck(id: string, data: Partial<DeckInput>): Promise<Deck> {
+    return this.client.fetch.patch<Deck>(E.deck(id), data);
+  }
+  deleteDeck(id: string): Promise<void> {
+    return this.client.fetch.delete<void>(E.deck(id));
+  }
+
+  // --- Generation pipeline (mirrors the n8n agent tools) ---
+  /** Derive the style spec (if absent) and generate every slide image async. */
+  generateDeck(id: string, data?: GenerateDeckInput): Promise<Deck> {
+    return this.client.fetch.post<Deck>(E.generate(id), data);
+  }
+  /** Per-slide progress, for polling while generation/compile runs. */
+  getDeckStatus(id: string): Promise<DeckGenerationStatus> {
+    return this.client.fetch.get<DeckGenerationStatus>(E.status(id));
+  }
+  /** Build the Google-Slides-equivalent deck and export PPTX + PDF. */
+  compileDeck(id: string): Promise<CompileResult> {
+    return this.client.fetch.post<CompileResult>(E.compile(id), undefined);
+  }
+
+  // --- Slides ---
+  listSlides(id: string): Promise<Slide[]> {
+    return this.client.fetch.get<Slide[]>(E.slides(id));
+  }
+  updateSlide(id: string, slideNumber: number, data: SlideInput): Promise<Slide> {
+    return this.client.fetch.patch<Slide>(E.slide(id, slideNumber), data);
+  }
+  /** Regenerate a single slide image (keeps the deck style spec). */
+  regenerateSlide(id: string, slideNumber: number, data?: RegenerateSlideInput): Promise<Slide> {
+    return this.client.fetch.post<Slide>(E.regenerate(id, slideNumber), data);
+  }
+  reorderSlides(id: string, order: number[]): Promise<void> {
+    return this.client.fetch.post<void>(E.reorder(id), { order });
+  }
+}

package/src/lib/team-invitations-api.ts

@@ -0,0 +1,49 @@
+/**
+ * TeamInvitations API wrapper for /api/v1/team-invitations/*.
+ *
+ * The accept endpoint is intentionally public-ish — it accepts an unauth
+ * caller carrying the one-time invite token in the body. The TeamMember
+ * row is created idempotently by the backend manager (startsim-tsm).
+ */
+
+import type { ApiClient } from './api-client';
+import { ENDPOINTS } from '../constants/endpoints';
+import type {
+  TeamInvitation,
+  TeamInvitationListParams,
+  CreateTeamInvitationInput,
+} from '../types/team';
+import type { PaginatedResponse } from '../types';
+
+export class TeamInvitationsApi {
+  constructor(private client: ApiClient) {}
+
+  list(params?: TeamInvitationListParams): Promise<PaginatedResponse<TeamInvitation>> {
+    return this.client.fetch.get<PaginatedResponse<TeamInvitation>>(
+      ENDPOINTS.TEAM_INVITATIONS,
+      { params },
+    );
+  }
+
+  /**
+   * Send a single invitation. The create response includes the raw token;
+   * subsequent reads will redact it.
+   */
+  create(input: CreateTeamInvitationInput): Promise<TeamInvitation> {
+    return this.client.fetch.post<TeamInvitation>(ENDPOINTS.TEAM_INVITATIONS, input);
+  }
+
+  revoke(id: string): Promise<void> {
+    return this.client.fetch.post<void>(ENDPOINTS.TEAM_INVITATION_REVOKE(id));
+  }
+
+  /**
+   * Accept an invitation. The caller posts the one-time token; the backend
+   * wires the TeamMember idempotently (startsim-tsm).
+   */
+  accept(id: string, token: string): Promise<TeamInvitation> {
+    return this.client.fetch.post<TeamInvitation>(ENDPOINTS.TEAM_INVITATION_ACCEPT(id), {
+      token,
+    });
+  }
+}

package/src/lib/teams-api.ts

@@ -0,0 +1,73 @@
+/**
+ * Teams API wrapper for /api/v1/teams/* plus the bulk-mgmt actions shipped
+ * by startsim-tsm (bulk-invite, remove-member, update-role).
+ *
+ * The Django TeamViewSet accepts numeric id OR slug. Member-mutation
+ * endpoints take user_id in the body, not the URL. startsim-o7s.
+ */
+
+import type { ApiClient } from './api-client';
+import { ENDPOINTS } from '../constants/endpoints';
+import type {
+  Team,
+  TeamMember,
+  TeamListParams,
+  BulkInviteEntry,
+  BulkInviteResult,
+  TeamRole,
+} from '../types/team';
+import type { PaginatedResponse } from '../types';
+
+/** Shape returned by /team-members/my-teams/ — a flat array of memberships. */
+export interface MyTeamMembership extends TeamMember {
+  team?: Team;
+}
+
+export class TeamsApi {
+  constructor(private client: ApiClient) {}
+
+  /** List teams visible to the current user. */
+  list(params?: TeamListParams): Promise<PaginatedResponse<Team>> {
+    return this.client.fetch.get<PaginatedResponse<Team>>(ENDPOINTS.TEAMS, { params });
+  }
+
+  /** Retrieve a single team by id or slug. */
+  retrieve(idOrSlug: string): Promise<Team> {
+    return this.client.fetch.get<Team>(ENDPOINTS.TEAM(idOrSlug));
+  }
+
+  /** List members of a team. Backend returns the full set (no pagination). */
+  members(idOrSlug: string): Promise<TeamMember[]> {
+    return this.client.fetch.get<TeamMember[]>(ENDPOINTS.TEAM_MEMBERS(idOrSlug));
+  }
+
+  /**
+   * Bulk-invite endpoint shipped by startsim-tsm. Sends one POST with the
+   * full list of {email, role} pairs and returns invited + skipped.
+   */
+  bulkInvite(idOrSlug: string, invitations: BulkInviteEntry[]): Promise<BulkInviteResult> {
+    return this.client.fetch.post<BulkInviteResult>(ENDPOINTS.TEAM_BULK_INVITE(idOrSlug), {
+      invitations,
+    });
+  }
+
+  /** Remove a member from the team. user_id goes in the body (not the URL). */
+  removeMember(idOrSlug: string, userId: string): Promise<void> {
+    return this.client.fetch.post<void>(ENDPOINTS.TEAM_REMOVE_MEMBER(idOrSlug), {
+      userId,
+    });
+  }
+
+  /** Promote/demote a member — fails if it would leave zero OWNERs. */
+  updateRole(idOrSlug: string, userId: string, role: TeamRole): Promise<TeamMember> {
+    return this.client.fetch.post<TeamMember>(ENDPOINTS.TEAM_UPDATE_ROLE(idOrSlug), {
+      userId,
+      role,
+    });
+  }
+
+  /** Return the current user's membership rows across every team they touch. */
+  myTeams(): Promise<MyTeamMembership[]> {
+    return this.client.fetch.get<MyTeamMembership[]>(ENDPOINTS.TEAM_MEMBERS_MY_TEAMS);
+  }
+}

package/src/lib/users-api.ts

@@ -7,6 +7,8 @@ import type {
   UpdateProfileRequest,
   ChangePasswordRequest,
   ChangePasswordResponse,
+  EarlyRegisterRequest,
+  EarlyRegisterResponse,
 } from '../types/user';
 import { ENDPOINTS } from '../constants/endpoints';
 import type { ApiClient } from './api-client';
@@ -37,4 +39,15 @@ export class UsersApi {
       data
     );
   }
+
+  /**
+   * Passwordless early-access registration (name + email only).
+   * Public endpoint — no auth token required.
+   */
+  async earlyRegister(data: EarlyRegisterRequest): Promise<EarlyRegisterResponse> {
+    return this.client.fetch.post<EarlyRegisterResponse>(
+      ENDPOINTS.AUTH_EARLY_REGISTER,
+      data
+    );
+  }
 }

package/src/lib/workflows-api.test.ts

@@ -0,0 +1,129 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { WorkflowsApi } from './workflows-api';
+
+function makeApi() {
+  const fetch = { get: vi.fn(), post: vi.fn(), patch: vi.fn(), delete: vi.fn() };
+  const api = new WorkflowsApi({ fetch } as never);
+  return { api, fetch };
+}
+
+describe('WorkflowsApi', () => {
+  let api: WorkflowsApi;
+  let fetch: {
+    get: ReturnType<typeof vi.fn>;
+    post: ReturnType<typeof vi.fn>;
+    patch: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(() => {
+    ({ api, fetch } = makeApi());
+  });
+
+  // --- Workflows CRUD ---
+  it('listWorkflows hits the workflows endpoint with params', async () => {
+    fetch.get.mockResolvedValue({ results: [], count: 0 });
+    await api.listWorkflows({ page: 2 });
+    expect(fetch.get).toHaveBeenCalledWith('api/v1/workflows', { params: { page: 2 } });
+  });
+
+  it('getWorkflow fetches a single workflow by id', async () => {
+    fetch.get.mockResolvedValue({ id: 'w1', name: 'Onboarding' });
+    const w = await api.getWorkflow('w1');
+    expect(fetch.get).toHaveBeenCalledWith('api/v1/workflows/w1');
+    expect(w.name).toBe('Onboarding');
+  });
+
+  it('createWorkflow posts the workflow input', async () => {
+    fetch.post.mockResolvedValue({ id: 'w1', name: 'Onboarding' });
+    await api.createWorkflow({ name: 'Onboarding', description: 'desc' });
+    expect(fetch.post).toHaveBeenCalledWith('api/v1/workflows', {
+      name: 'Onboarding',
+      description: 'desc',
+    });
+  });
+
+  it('updateWorkflow patches by id', async () => {
+    fetch.patch.mockResolvedValue({ id: 'w1', name: 'New' });
+    await api.updateWorkflow('w1', { name: 'New' });
+    expect(fetch.patch).toHaveBeenCalledWith('api/v1/workflows/w1', { name: 'New' });
+  });
+
+  it('deleteWorkflow deletes by id', async () => {
+    fetch.delete.mockResolvedValue(undefined);
+    await api.deleteWorkflow('w1');
+    expect(fetch.delete).toHaveBeenCalledWith('api/v1/workflows/w1');
+  });
+
+  // --- Node types ---
+  it('getNodeTypes fetches the node-type registry', async () => {
+    fetch.get.mockResolvedValue([
+      { slug: 'http', category: 'action', label: 'HTTP Request', parameterSchema: {}, outputLabels: ['main'] },
+    ]);
+    const types = await api.getNodeTypes();
+    expect(fetch.get).toHaveBeenCalledWith('api/v1/workflows/node-types');
+    expect(types[0].slug).toBe('http');
+  });
+
+  // --- Execution ---
+  it('executeWorkflow posts context and returns an executionId', async () => {
+    fetch.post.mockResolvedValue({ executionId: 'e1', status: 'running' });
+    const res = await api.executeWorkflow('w1', { foo: 'bar' });
+    expect(fetch.post).toHaveBeenCalledWith('api/v1/workflows/w1/execute', { contextData: { foo: 'bar' } });
+    expect(res.executionId).toBe('e1');
+    expect(res.status).toBe('running');
+  });
+
+  it('executeWorkflow works with no context data', async () => {
+    fetch.post.mockResolvedValue({ executionId: 'e2', status: 'pending' });
+    await api.executeWorkflow('w1');
+    expect(fetch.post).toHaveBeenCalledWith('api/v1/workflows/w1/execute', { contextData: undefined });
+  });
+
+  it('getExecution fetches a single execution detail by executionId', async () => {
+    fetch.get.mockResolvedValue({ status: 'running', state: {}, nodeExecutions: [] });
+    const e = await api.getExecution('e1');
+    expect(fetch.get).toHaveBeenCalledWith('api/v1/workflows/executions/e1');
+    expect(e.status).toBe('running');
+  });
+
+  it('listExecutions fetches executions for a workflow with params', async () => {
+    fetch.get.mockResolvedValue({ results: [], count: 0 });
+    await api.listExecutions('w1', { page: 1 });
+    expect(fetch.get).toHaveBeenCalledWith('api/v1/workflows/w1/executions', { params: { page: 1 } });
+  });
+
+  it('cancelExecution posts to the cancel endpoint', async () => {
+    fetch.post.mockResolvedValue({ id: 'e1', status: 'cancelled' });
+    await api.cancelExecution('e1');
+    expect(fetch.post).toHaveBeenCalledWith('api/v1/workflows/executions/e1/cancel', undefined);
+  });
+
+  it('retryExecution posts to the retry endpoint and returns an executionId', async () => {
+    fetch.post.mockResolvedValue({ executionId: 'e2', status: 'pending' });
+    const res = await api.retryExecution('e1');
+    expect(fetch.post).toHaveBeenCalledWith('api/v1/workflows/executions/e1/retry', undefined);
+    expect(res.executionId).toBe('e2');
+  });
+
+  // --- Lifecycle ---
+  it('cloneWorkflow posts to the clone endpoint', async () => {
+    fetch.post.mockResolvedValue({ id: 'w2', name: 'Onboarding (copy)' });
+    const w = await api.cloneWorkflow('w1');
+    expect(fetch.post).toHaveBeenCalledWith('api/v1/workflows/w1/clone', undefined);
+    expect(w.id).toBe('w2');
+  });
+
+  it('publishWorkflow posts to the publish endpoint', async () => {
+    fetch.post.mockResolvedValue({ id: 'w1', isActive: true });
+    await api.publishWorkflow('w1');
+    expect(fetch.post).toHaveBeenCalledWith('api/v1/workflows/w1/publish', undefined);
+  });
+
+  it('getVersions fetches the workflow version history', async () => {
+    fetch.get.mockResolvedValue([{ id: 'w1', version: 1 }]);
+    const versions = await api.getVersions('w1');
+    expect(fetch.get).toHaveBeenCalledWith('api/v1/workflows/w1/versions');
+    expect(versions[0].version).toBe(1);
+  });
+});