TypeScript client

npm i @sedgemark/client
SEDGEMARK_API_KEY=sk_... npx sedgemark generate --base-url https://acme.sedgemark.app

import { createClient } from '@sedgemark/client'
import type { SedgemarkSchema } from './sedgemark.types'

const sm = createClient<SedgemarkSchema>({
  baseUrl: 'https://acme.sedgemark.app',
  apiKey: process.env.SEDGEMARK_API_KEY, // omit entirely for public collections
})

// Typed as your own collection: collection('blog_pst') is a compile error.
const { data, total } = await sm.collection('blog_post').list({ limit: 20 })

// One entry (the bare row), every entry (pagination handled), a media URL.
const post = await sm.collection('blog_post').get(id)
const everything = await sm.collection('blog_post').listAll()
const cover = post.cover_image ? sm.resolveMedia(post.cover_image) : null

import { createClient, SedgemarkApiError } from '@sedgemark/client'

const sm = createClient<SedgemarkSchema>({ baseUrl: 'https://acme.sedgemark.app' })
// No apiKey, and never configure one for browser-side form code.

// When the form RENDERS, this starts the anti-spam token fetch, so the
// token is old enough by the time the visitor submits:
const form = sm.form('contact')

// Later, in the submit handler:
try {
  const result = await form.submit({ email: 'visitor@example.com', message: 'Hello!' })
  // result.id === null means the honeypot was tripped: show the thank-you.
} catch (err) {
  if (err instanceof SedgemarkApiError) {
    err.errors // [{ field, message }]: every failing field at once
    err.code   // 'token_invalid' | 'token_expired' | 'submitted_too_fast' | null
  }
}

curl https://acme.sedgemark.app/api/dashboard/sdk \
  -H "Authorization: Bearer $SEDGEMARK_API_KEY" \
  -o src/lib/sedgemark-client.ts

import { SedgemarkClient, fetchAll, resolveMedia, excerpt } from './sedgemark-client'

const client = new SedgemarkClient({
  baseUrl: 'https://acme.sedgemark.app',
  apiKey: process.env.SEDGEMARK_API_KEY, // omit entirely for public collections
})

// One page. Typed as your own collection, not `any`.
const { data, total } = await client.blog_post.list({ limit: 20, offset: 0 })

// One entry.
const post = await client.blog_post.get(id)

// Every entry, pagination handled for you.
const everything = await fetchAll((opts) => client.blog_post.list(opts))

// A media field id turned into a URL.
const cover = post.cover_image
  ? resolveMedia(post.cover_image, { baseUrl: 'https://acme.sedgemark.app' })
  : null

// A plain-text summary from a rich_text field.
const summary = excerpt(post.body, { maxLength: 160 })

import { SedgemarkApiError } from './sedgemark-client'

try {
  await client.blog_post.get(id)
} catch (err) {
  if (err instanceof SedgemarkApiError) {
    err.status  // the HTTP status
    err.errors  // [{ field, message }] on a form validation failure
    err.code    // 'token_invalid' | 'token_expired' | 'submitted_too_fast' | null
  }
  throw err
}

import {
  SedgemarkClient,
  contactFormFields,
  contactHoneypotField,
  validateContactPayload,
} from './sedgemark-client'

// No apiKey, and never configure one for browser-side form code.
const client = new SedgemarkClient({ baseUrl: 'https://acme.sedgemark.app' })

const payload = { email: 'visitor@example.com', message: 'Hello!' }

// Optional: catches problems without a round trip. Returns every failing
// field at once, exactly as the server would.
const errors = validateContactPayload(payload)

if (errors.length === 0) {
  const result = await client.forms.contact.submit(payload)
  // { ok: true, id, submitted_at, ignored?: [...] }
  // result.id === null means the honeypot was tripped: show the thank-you.
}

{contactFormFields.map(({ slug, name, required, values, attrs }) => {
  const { control, ...inputAttrs } = attrs
  return (
    <label>
      {name}{required && ' *'}
      {control === 'textarea' ? (
        <textarea name={slug} {...inputAttrs} />
      ) : control === 'select' ? (
        <select name={slug} {...inputAttrs}>
          <option value="">Choose…</option>
          {values.map((v) => <option value={v}>{v}</option>)}
        </select>
      ) : (
        <input name={slug} {...inputAttrs} />
      )}
    </label>
  )
})}

// src/content.config.ts
import { defineCollection, z } from 'astro:content'

const SEDGEMARK_BASE_URL = 'https://acme.sedgemark.app'
const API_KEY = import.meta.env.SEDGEMARK_API_KEY // omit entirely for public collections

/** A content-layer loader is ~15 lines of fetch: no extra package needed for it. */
function sedgemarkLoader(collection) {
  return {
    name: `sedgemark:${collection}`,
    load: async ({ store, parseData }) => {
      store.clear()
      const headers = API_KEY ? { Authorization: `Bearer ${API_KEY}` } : {}

      // /api/v1 returns { data, total, limit, offset } and has no hasMore field,
      // so loop until you have seen `total` rows.
      for (let offset = 0; ; ) {
        const url = `${SEDGEMARK_BASE_URL}/api/v1/${collection}?limit=200&offset=${offset}`
        const res = await fetch(url, { headers })
        if (!res.ok) throw new Error(`${collection}: ${res.status}`)
        const page = await res.json()
        for (const row of page.data) {
          store.set({ id: row.id, data: await parseData({ id: row.id, data: row }) })
        }
        offset += page.data.length
        if (page.data.length === 0 || offset >= page.total) break
      }
    },
  }
}

/** A media field holds an asset id. This endpoint 302s to a presigned URL. */
const resolveMedia = (id) => `${SEDGEMARK_BASE_URL}/api/v1/media/${id}`

const blog = defineCollection({
  loader: sedgemarkLoader('blog_post'),
  schema: z
    .object({
      title: z.string(),
      body: z.string(),                    // pre-sanitized HTML
      cover_image: z.string().nullable(),  // a media asset id, not a URL
    })
    .transform((entry) => ({
      ...entry,
      coverImageUrl: entry.cover_image ? resolveMedia(entry.cover_image) : null,
    })),
})

export const collections = { blog }

---
// src/pages/blog/[id].astro
import type { GetStaticPaths } from 'astro'
import { getCollection } from 'astro:content'

// A dynamic route in Astro's default static output needs getStaticPaths.
// Entries are keyed by their Sedgemark entry id.
export const getStaticPaths: GetStaticPaths = async () => {
  const posts = await getCollection('blog')
  return posts.map((post) => ({ params: { id: post.id }, props: { post } }))
}

const { post } = Astro.props
---
{post.data.coverImageUrl && (
  <img src={post.data.coverImageUrl} alt="" />
)}
<Fragment set:html={post.data.body} />