Overview

import { createClient } from "@dyrected/sdk";
import type { DyrectedSchema } from "./dyrected-types";

const client = createClient<DyrectedSchema>({
  baseUrl: "https://example.com",
  apiKey: process.env.DYRECTED_API_KEY,
});

const { docs: posts } = await client.collection("posts").find({
  where: { status: { equals: "published" } },
  sort: "-createdAt",
  depth: 1,
});

const { docs } = await client.collection("posts").find({
  search: "grace hopper",
  where: { status: { equals: "published" } },
})

// 1. Create a media folder
const folder = await client.createFolder("media", {
  name: "Summer Campaign",
  color: "#3b82f6",
});

// 2. List all folders in a collection
const { docs: folders } = await client.listFolders("media");

// 3. Upload a file directly into a folder
const asset = await client.collection("media").upload(myFile, {
  folderId: folder.id,
  alt: "Summer campaign banner",
});

// 4. Replace an existing file in-place (keeps the same document ID)
const updatedAsset = await client.replaceMedia(asset.id, newFile);

// 5. Delete multiple assets in batch
await client.deleteMany("media", {
  ids: ["asset-1", "asset-2"],
});

// 1. Invite a user with initial role data and custom action URL
const invite = await client.collection("users").invite("[email protected]", {
  inviteUrl: "https://myapp.com/accept-invite",
  data: { roles: ["editor"], name: "Alex" },
});
console.log(`Invite sent: ${invite.emailSent}, token: ${invite.token}`);

// 2. Mint a headless invite token without sending an email (for SMS, custom delivery)
const headless = await client.collection("users").createInviteToken({
  email: "[email protected]",
  inviteUrl: "https://myapp.com/onboarding",
});

// 3. Verify an invite or reset token when your frontend component mounts
const check = await client.collection("users").verifyToken(tokenFromUrl, "invite");
if (check.valid) {
  console.log(`Token verified for ${check.email}`);
} else {
  console.error(`Token invalid or expired: ${check.error}`);
}

// 4. Complete invite acceptance with a user-chosen password
const { token, user } = await client.collection("users").acceptInvite(
  tokenFromUrl,
  "secure-password-123",
  { department: "Design" },
);
client.setToken(token);

// 5. Send a password reset or mint a headless reset token
await client.collection("users").sendPasswordReset("[email protected]", {
  resetUrl: "https://myapp.com/reset-password",
});
const resetToken = await client.collection("users").createPasswordResetToken("[email protected]");

export interface AuditEntry {
  id: string;
  collection: string;
  documentId: string | null;
  operation: string;
  user: string | null;
  timestamp: string;
  changes?: string | Record<string, unknown> | null;
}

export interface BaseSchema {
  collections: Record<string, UnknownRecord>;
  globals: Record<string, UnknownRecord>;
}

export function createClient<TSchema extends SchemaShape = RegisteredSchema>(
  config: DyrectedClientConfig,
): DyrectedClient<TSchema>

export class DyrectedClient<TSchema extends SchemaShape = RegisteredSchema> {
}

export interface DyrectedClientConfig {
  baseUrl: string;
  apiKey?: string;
  siteId?: string;
  headers?: Record<string, string>;
  fetch?: typeof fetch;
  /**
   * Callback invoked when a 401 Unauthorized response is returned from an authenticated endpoint.
   */
  onAuthError?: (error: DyrectedError) => void;
  /**
   * Default relationship population depth applied to document reads
   * (`find`, `findOne`, `global().get()`, and media listing) when a call
   * does not pass its own `depth`. Defaults to `1`.
   */
  defaultDepth?: number;
}

export class DyrectedError extends Error {
}

export function getPreviewToken(
  search: string | URLSearchParams | Record<string, unknown> | undefined | null,
): string | null

export type InferSchema<
  TCollections extends Record<string, CollectionConfig<UnknownRecord>>,
  TGlobals extends Record<string, GlobalConfig<UnknownRecord>> = Record<
    never,
    never
  >,
> = {
  collections: { [K in keyof TCollections]: ExtractDoc<TCollections[K]> };
  globals: { [K in keyof TGlobals]: ExtractDoc<TGlobals[K]> };
};

export interface InviteOptions {
  inviteUrl?: string;
  sendEmail?: boolean;
  data?: UnknownRecord;
  [key: string]: unknown;
}

export interface InviteResult {
  success: boolean;
  message: string;
  token: string;
  inviteUrl: string;
  emailSent: boolean;
  emailError?: string;
}

export interface MediaFolder {
  id: string;
  name: string;
  slug: string;
  collection: string;
  parentId: string | null;
  path: string;
  color?: string | null;
  createdAt?: string;
  updatedAt?: string;
}

export interface PasswordResetOptions {
  resetUrl?: string;
  sendEmail?: boolean;
}

export interface PasswordResetResult {
  success: boolean;
  message: string;
  emailSent: boolean;
  emailError?: string;
  token?: string;
  resetUrl?: string;
}

export const PREVIEW_TOKEN_PARAM = "dyPreview";

export interface Register {}

export type RegisteredComponentKeys = Register extends { componentKeys: infer K }
  ? K
  : {
      fields?: string;
      dashboard?: string;
      collectionList?: string;
      collectionView?: string;
      forms?: string;
      viewLayouts?: string;
      pages?: string;
      customComponents?: string;
    };

export type RegisteredSchema = Register extends { schema: infer S }
  ? S extends SchemaShape
    ? S
    : BaseSchema
  : BaseSchema;

export interface RunActionArgs {
  /** Target a single document (row action). */
  id?: string;
  /** Target multiple documents (bulk action). */
  ids?: string[];
  /** Values collected from the action's input form dialog. */
  input?: Record<string, unknown>;
}

export interface SchemaResponse {
  blocks?: Block[];
  collections: CollectionConfig[];
  globals: GlobalConfig[];
  admin?: AdminConfig;
  adminAuth?: PublicAdminAuthConfig;
  hasStorage?: boolean;
  configDiagnostics?: ConfigDiagnostic[];
  ai?: SerializedSchemaAIConfig;
  trash?: {
    enabled?: boolean;
    retentionDays?: number | null;
    allowPermanentDelete?: boolean;
  };
  adminHealth?: {
    emailConfigured?: boolean;
    secureAuthSecretConfigured?: boolean;
    authCollectionConfigured?: boolean;
    uploadCollectionConfigured?: boolean;
    trashPurgeOverdue?: boolean;
  };
}

export interface SchemaShape {
  collections: Record<string, object>;
  globals: Record<string, object>;
}

export interface SerializedCollectionConfig {
  slug: string;
  labels?: { singular?: string; plural?: string };
  shared?: boolean;
  siteId?: string;
  ai?: unknown;
  access?: {
    read?: boolean | string;
    create?: boolean | string;
    update?: boolean | string;
    delete?: boolean | string;
  };
  fields: SerializedField[];
  upload?: boolean;
  auth?: boolean;
  audit?: boolean;
  drafts?: boolean;
  defaultView?: string;
  views?: unknown[];
  admin?: Record<string, unknown>;
  detail?: unknown;
  workflow?: unknown;
}

export interface SerializedField {
  name: string;
  type: string;
  label?: string;
  required?: boolean;
  unique?: boolean;
  min?: number;
  max?: number;
  step?: number;
  minLength?: number;
  maxLength?: number;
  pattern?: string;
  allowedTypes?: string[];
  maxSize?: number;
  virtual?: boolean;
  promoted?: boolean;
  ai?: {
    exclude?: boolean;
    redact?: boolean | "mask";
    allowRaw?: boolean;
  };
  defaultValue?: unknown;
  options?: unknown;
  relationTo?: string;
  hasMany?: boolean;
  fields?: SerializedField[];
  blocks?: unknown[];
  blockReferences?: string[];
  collection?: string;
  on?: string;
  limit?: number;
  admin?: Record<string, unknown>;
  access?: {
    read?: boolean | string;
    create?: boolean | string;
    update?: boolean | string;
  };
}

export interface SerializedGlobalConfig {
  slug: string;
  label?: string;
  shared?: boolean;
  siteId?: string;
  access?: {
    read?: boolean | string;
    update?: boolean | string;
  };
  fields: SerializedField[];
  admin?: Record<string, unknown>;
  detail?: unknown;
}

export interface SerializedSchemaAIConfig {
  enabled: boolean;
  provider?: string;
  model?: string;
}

export interface TokenVerificationResult {
  valid: boolean;
  email?: string;
  collection?: string;
  code?: string;
  message?: string;
}

export interface TransitionOptions {
  /**
   * The revision number currently shown to the user. When provided, the server
   * rejects the transition if the document has changed since it was loaded,
   * preventing lost-update races.
   */
  expectedRevision?: number;
  /** Required for transitions that have `requireComment: true` (e.g. `reject`). */
  comment?: string;
  /**
   * Extra data passed to the transition's server-side `onTransition` handler,
   * for example an amount the handler needs to act on.
   */
  input?: Record<string, unknown>;
}

export type TrashClient = ((collectionSlug?: string) => TrashOperations) & TrashOperations;

export interface TrashEmptyOptions {
  confirm?: string;
}

export interface TrashEntry {
  id: string;
  collection: string;
  docId: string;
  deletedAt: number;
  purgeAt: number | null;
  deletedBy?: string;
  title?: string;
  snapshot: Record<string, unknown>;
  createdAt?: string;
  updatedAt?: string;
}

export interface TrashKeepOptions {
  purgeAt?: Date | string | number | null;
}

export interface TrashListArgs {
  page?: number;
  limit?: number;
  search?: string;
  [key: string]: unknown;
}

export interface TrashOperations {
  list: (args?: TrashListArgs) => Promise<PaginatedResult<TrashEntry>>;
  get: (trashId: string) => Promise<TrashEntry>;
  restore: (trashId: string, options?: TrashRestoreOptions) => Promise<UnknownRecord>;
  restoreMany: (trashIds: string[]) => Promise<{ restored: string[]; failed: unknown[]; count: number }>;
  keep: (trashId: string, options?: TrashKeepOptions | boolean) => Promise<{ message: string; purgeAt: number | null }>;
  purge: (trashId: string) => Promise<{ message: string }>;
  empty: (options?: TrashEmptyOptions | string) => Promise<{ message: string; count: number }>;
}

export interface TrashRestoreOptions {
  overrides?: Record<string, unknown>;
}

export interface UploadOptions {
  /** Called with an integer 0–100 as the file bytes are sent. */
  onProgress?: (percent: number) => void;
  /** Abort the in-flight upload. */
  signal?: AbortSignal;
}

export interface WorkflowDocument {
  id: string;
  _workflow: WorkflowMetadata;
  [key: string]: unknown;
}

export interface WorkflowHistoryEntry {
  id: string;
  collection: string;
  documentId: string;
  transition: string;
  from: string;
  to: string;
  revision: number;
  comment: string | null;
  actorId: string | null;
  createdAt: string;
}