dineway 0.1.3

package/dist/client/external-auth-headers.d.mts

@@ -0,0 +1,38 @@
+import { t as Interceptor } from "../transport-gIL-e43D.mjs";
+
+//#region src/client/external-auth-headers.d.ts
+/**
+ * Parse headers from the DINEWAY_HEADERS env var.
+ * Format: newline-separated "Name: Value" pairs.
+ * Blank lines and malformed entries are silently skipped.
+ */
+declare function parseHeadersFromEnv(): Record<string, string>;
+/**
+ * Parse an array of "Name: Value" strings into a headers record.
+ * Malformed entries are silently skipped. Later values override earlier ones.
+ */
+declare function parseHeaderStrings(headers: string[]): Record<string, string>;
+/**
+ * Collect all --header flag values from process.argv.
+ *
+ * citty doesn't support repeatable string args, so argv is parsed directly.
+ * Handles both `--header "Name: Value"` and `--header="Name: Value"`.
+ */
+declare function parseHeadersFromArgv(): string[];
+/**
+ * Resolve custom headers from all sources.
+ * Priority: env var < CLI flags (later wins).
+ */
+declare function resolveCustomHeaders(): Record<string, string>;
+/**
+ * Creates a transport interceptor that injects custom headers on every request.
+ */
+declare function customHeadersInterceptor(headers: Record<string, string>): Interceptor;
+/**
+ * Creates a fetch wrapper that injects custom headers.
+ * Used by the CLI for raw fetch calls before the client is created.
+ */
+declare function createHeaderAwareFetch(headers: Record<string, string>): typeof fetch;
+declare function isRedirectResponse(response: Response): boolean;
+//#endregion
+export { createHeaderAwareFetch, customHeadersInterceptor, isRedirectResponse, parseHeaderStrings, parseHeadersFromArgv, parseHeadersFromEnv, resolveCustomHeaders };

package/dist/client/external-auth-headers.mjs

@@ -0,0 +1,101 @@
+//#region src/client/external-auth-headers.ts
+/**
+* Parse a single "Name: Value" header string. Returns null if malformed.
+*/
+function parseHeaderLine(line) {
+	const idx = line.indexOf(":");
+	if (idx === -1) return null;
+	const name = line.slice(0, idx).trim();
+	const value = line.slice(idx + 1).trim();
+	if (!name) return null;
+	return [name, value];
+}
+/**
+* Parse headers from the DINEWAY_HEADERS env var.
+* Format: newline-separated "Name: Value" pairs.
+* Blank lines and malformed entries are silently skipped.
+*/
+function parseHeadersFromEnv() {
+	const raw = process.env["DINEWAY_HEADERS"];
+	if (!raw) return {};
+	return parseHeaderStrings(raw.split("\n"));
+}
+/**
+* Parse an array of "Name: Value" strings into a headers record.
+* Malformed entries are silently skipped. Later values override earlier ones.
+*/
+function parseHeaderStrings(headers) {
+	const result = {};
+	for (const header of headers) {
+		const parsed = parseHeaderLine(header);
+		if (parsed) result[parsed[0]] = parsed[1];
+	}
+	return result;
+}
+/**
+* Collect all --header flag values from process.argv.
+*
+* citty doesn't support repeatable string args, so argv is parsed directly.
+* Handles both `--header "Name: Value"` and `--header="Name: Value"`.
+*/
+function parseHeadersFromArgv() {
+	const headers = [];
+	const argv = process.argv;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--header" || arg === "-H") {
+			const next = argv[i + 1];
+			if (next && !next.startsWith("-")) {
+				headers.push(next);
+				i++;
+			}
+		} else if (arg.startsWith("--header=")) headers.push(arg.slice(9));
+		else if (arg.startsWith("-H=")) headers.push(arg.slice(3));
+	}
+	return headers;
+}
+/**
+* Resolve custom headers from all sources.
+* Priority: env var < CLI flags (later wins).
+*/
+function resolveCustomHeaders() {
+	const envHeaders = parseHeadersFromEnv();
+	const cliHeaders = parseHeaderStrings(parseHeadersFromArgv());
+	return {
+		...envHeaders,
+		...cliHeaders
+	};
+}
+/**
+* Creates a transport interceptor that injects custom headers on every request.
+*/
+function customHeadersInterceptor(headers) {
+	const entries = Object.entries(headers);
+	if (entries.length === 0) return (request, next) => next(request);
+	return (request, next) => {
+		const nextHeaders = new Headers(request.headers);
+		for (const [name, value] of entries) nextHeaders.set(name, value);
+		return next(new Request(request, { headers: nextHeaders }));
+	};
+}
+/**
+* Creates a fetch wrapper that injects custom headers.
+* Used by the CLI for raw fetch calls before the client is created.
+*/
+function createHeaderAwareFetch(headers) {
+	if (Object.keys(headers).length === 0) return globalThis.fetch.bind(globalThis);
+	return (input, init) => {
+		const nextHeaders = new Headers(init?.headers);
+		for (const [name, value] of Object.entries(headers)) nextHeaders.set(name, value);
+		return globalThis.fetch(input, {
+			...init,
+			headers: nextHeaders
+		});
+	};
+}
+function isRedirectResponse(response) {
+	return response.status >= 300 && response.status < 400 && response.headers.has("location");
+}
+
+//#endregion
+export { createHeaderAwareFetch, customHeadersInterceptor, isRedirectResponse, parseHeaderStrings, parseHeadersFromArgv, parseHeadersFromEnv, resolveCustomHeaders };

package/dist/client/index.d.mts

@@ -0,0 +1,397 @@
+import { a as tokenInterceptor, i as devBypassInterceptor, n as createTransport, r as csrfInterceptor, t as Interceptor } from "../transport-gIL-e43D.mjs";
+
+//#region src/client/portable-text.d.ts
+/**
+ * Portable Text <-> Markdown conversion layer.
+ *
+ * Three tiers of block handling:
+ *   Tier 1: Standard PT blocks <-> standard Markdown (headings, paragraphs, lists, etc.)
+ *   Tier 2: Dineway custom blocks <-> Markdown directives (future)
+ *   Tier 3: Unknown blocks <-> opaque HTML comment fences (preserved, not editable)
+ */
+/** Minimal Portable Text block shape */
+interface PortableTextBlock {
+  _type: string;
+  _key?: string;
+  style?: string;
+  level?: number;
+  listItem?: string;
+  markDefs?: MarkDef[];
+  children?: PortableTextSpan[];
+  [key: string]: unknown;
+}
+interface PortableTextSpan {
+  _type: string;
+  _key?: string;
+  text?: string;
+  marks?: string[];
+  [key: string]: unknown;
+}
+interface MarkDef {
+  _key: string;
+  _type: string;
+  href?: string;
+  [key: string]: unknown;
+}
+/**
+ * Convert Portable Text blocks to Markdown.
+ * Unknown block types are serialized as opaque fences.
+ */
+declare function portableTextToMarkdown(blocks: PortableTextBlock[]): string;
+/**
+ * Convert Markdown to Portable Text blocks.
+ * Opaque fences (<!--ec:block ... -->) are deserialized and spliced back in.
+ */
+declare function markdownToPortableText(markdown: string): PortableTextBlock[];
+//#endregion
+//#region src/client/index.d.ts
+interface DinewayClientOptions {
+  /** Base URL of the Dineway instance */
+  baseUrl: string;
+  /** API token (ec_pat_...) or OAuth token (ec_oat_...) */
+  token?: string;
+  /** OAuth refresh token for auto-refresh on 401 */
+  refreshToken?: string;
+  /** Called when a token is refreshed (for persisting new access token) */
+  onTokenRefresh?: (accessToken: string, expiresIn: number) => void;
+  /** Use dev-bypass authentication (localhost only) */
+  devBypass?: boolean;
+  /** Additional request interceptors */
+  interceptors?: Interceptor[];
+}
+/** Standard API error shape */
+interface ApiError {
+  code: string;
+  message: string;
+  details?: Record<string, unknown>;
+}
+/** Standard API response wrapper */
+interface ClientResponse<T> {
+  success: true;
+  data: T;
+}
+/** Paginated list response */
+interface ListResult<T> {
+  items: T[];
+  nextCursor?: string;
+}
+/** Content item as returned by the API */
+interface ContentItem {
+  id: string;
+  type: string;
+  slug: string | null;
+  status: string;
+  data: Record<string, unknown>;
+  authorId: string | null;
+  createdAt: string;
+  updatedAt: string;
+  publishedAt: string | null;
+  scheduledAt: string | null;
+  liveRevisionId: string | null;
+  draftRevisionId: string | null;
+  locale: string | null;
+  translationGroup: string | null;
+  _rev?: string;
+}
+/** Collection metadata */
+interface Collection {
+  slug: string;
+  label: string;
+  labelSingular: string;
+  description?: string;
+  icon?: string;
+  supports: string[];
+}
+/** Collection with fields */
+interface CollectionWithFields extends Collection {
+  fields: Field[];
+}
+/** Field metadata */
+interface Field {
+  slug: string;
+  label: string;
+  type: string;
+  required: boolean;
+  unique: boolean;
+  defaultValue?: unknown;
+  validation?: unknown;
+  widget?: string;
+  options?: unknown;
+  sortOrder?: number;
+}
+/** Media item */
+interface MediaItem {
+  id: string;
+  filename: string;
+  key: string;
+  mimeType: string;
+  size: number;
+  width?: number;
+  height?: number;
+  alt?: string;
+  caption?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+/** Search result */
+interface SearchResult {
+  id: string;
+  collection: string;
+  title: string;
+  excerpt?: string;
+  score: number;
+}
+/** Taxonomy */
+interface Taxonomy {
+  name: string;
+  label: string;
+  hierarchical: boolean;
+}
+/** Taxonomy term */
+interface Term {
+  id: string;
+  slug: string;
+  label: string;
+  parentId?: string | null;
+  description?: string;
+  count?: number;
+}
+/** Menu */
+interface Menu {
+  name: string;
+  label: string;
+}
+/** Menu with items */
+interface MenuWithItems extends Menu {
+  items: MenuItem[];
+}
+/** Menu item */
+interface MenuItem {
+  id: string;
+  type: string;
+  label: string;
+  customUrl?: string;
+  referenceCollection?: string;
+  referenceId?: string;
+  target?: string;
+  parentId?: string | null;
+  sortOrder: number;
+}
+/** Full schema export (returned by /api/schema) */
+interface SchemaExport {
+  collections: Array<{
+    slug: string;
+    label: string;
+    labelSingular: string;
+    description?: string;
+    icon?: string;
+    supports: string[];
+    fields: Array<{
+      slug: string;
+      label: string;
+      type: string;
+      required: boolean;
+      unique: boolean;
+      defaultValue?: unknown;
+      validation?: unknown;
+      widget?: string;
+      options?: unknown;
+    }>;
+  }>;
+  version: string;
+}
+/** Manifest — full schema + field descriptors */
+interface Manifest {
+  version: string;
+  hash: string;
+  collections: Record<string, {
+    label: string;
+    labelSingular: string;
+    supports: string[];
+    fields: Record<string, {
+      kind: string;
+      label?: string;
+      required?: boolean;
+    }>;
+  }>;
+}
+declare class DinewayApiError extends Error {
+  readonly status: number;
+  readonly code: string;
+  readonly details?: Record<string, unknown> | undefined;
+  constructor(status: number, code: string, message: string, details?: Record<string, unknown> | undefined);
+}
+declare class DinewayClientError extends Error {
+  constructor(message: string);
+}
+declare class DinewayClient {
+  private readonly baseUrl;
+  private readonly transport;
+  /** Cached field schemas per collection for PT conversion */
+  private fieldSchemaCache;
+  constructor(options: DinewayClientOptions);
+  /** List all collections */
+  collections(): Promise<Collection[]>;
+  /** Get a single collection with its fields */
+  collection(slug: string): Promise<CollectionWithFields>;
+  /** Create a collection */
+  createCollection(input: {
+    slug: string;
+    label: string;
+    labelSingular?: string;
+    description?: string;
+    icon?: string;
+    supports?: string[];
+  }): Promise<Collection>;
+  /** Delete a collection */
+  deleteCollection(slug: string): Promise<void>;
+  /** Create a field on a collection */
+  createField(collection: string, input: {
+    slug: string;
+    type: string;
+    label: string;
+    required?: boolean;
+    unique?: boolean;
+    defaultValue?: unknown;
+    validation?: unknown;
+    widget?: string;
+    options?: unknown;
+    sortOrder?: number;
+  }): Promise<Field>;
+  /** Delete a field from a collection */
+  deleteField(collection: string, fieldSlug: string): Promise<void>;
+  /** Get full manifest (schema + field descriptors + features) */
+  manifest(): Promise<Manifest>;
+  /** Export full schema as JSON (used by `dineway types`) */
+  schemaExport(): Promise<SchemaExport>;
+  /** Export schema as TypeScript type definitions (used by `dineway types`) */
+  schemaTypes(): Promise<string>;
+  /** List content in a collection */
+  list(collection: string, options?: {
+    status?: string;
+    limit?: number;
+    cursor?: string;
+    orderBy?: string;
+    order?: "asc" | "desc";
+    locale?: string;
+  }): Promise<ListResult<ContentItem>>;
+  /** Async iterator that auto-follows cursors */
+  listAll(collection: string, options?: {
+    status?: string;
+    limit?: number;
+    orderBy?: string;
+    order?: "asc" | "desc";
+    locale?: string;
+  }): AsyncGenerator<ContentItem>;
+  /**
+   * Get a single content item. Returns the item with a `_rev` token
+   * that can be passed to update() for optimistic concurrency.
+   */
+  get(collection: string, id: string, options?: {
+    raw?: boolean;
+    locale?: string;
+  }): Promise<ContentItem>;
+  /** Create a new content item */
+  create(collection: string, input: {
+    data: Record<string, unknown>;
+    slug?: string;
+    status?: string;
+    locale?: string;
+    translationOf?: string;
+  }): Promise<ContentItem>;
+  /**
+   * Update a content item. Pass `_rev` from a prior get() for optimistic
+   * concurrency — the server returns 409 if the item has changed.
+   * Omit `_rev` for a blind write (no conflict detection).
+   */
+  update(collection: string, id: string, input: {
+    data?: Record<string, unknown>;
+    slug?: string;
+    status?: string;
+    _rev?: string;
+  }): Promise<ContentItem>;
+  /** Delete (soft) a content item */
+  delete(collection: string, id: string): Promise<void>;
+  /** Publish a content item */
+  publish(collection: string, id: string): Promise<void>;
+  /** Unpublish a content item */
+  unpublish(collection: string, id: string): Promise<void>;
+  /** Schedule publishing */
+  schedule(collection: string, id: string, options: {
+    at: string;
+  }): Promise<void>;
+  /** Restore a trashed content item */
+  restore(collection: string, id: string): Promise<void>;
+  /** Compare live and draft revisions */
+  compare(collection: string, id: string): Promise<{
+    hasChanges: boolean;
+    live: Record<string, unknown> | null;
+    draft: Record<string, unknown> | null;
+  }>;
+  /** Discard draft revision, reverting to the published version */
+  discardDraft(collection: string, id: string): Promise<void>;
+  /**
+   * Get all translations of a content item.
+   * Returns the translation group ID and a summary of each locale version.
+   */
+  translations(collection: string, id: string): Promise<{
+    translationGroup: string;
+    translations: Array<{
+      id: string;
+      locale: string | null;
+      slug: string | null;
+      status: string;
+      updatedAt: string;
+    }>;
+  }>;
+  /** List media items */
+  mediaList(options?: {
+    mimeType?: string;
+    limit?: number;
+    cursor?: string;
+  }): Promise<ListResult<MediaItem>>;
+  /** Get a single media item */
+  mediaGet(id: string): Promise<MediaItem>;
+  /** Upload a media file */
+  mediaUpload(file: Uint8Array | Blob, filename: string, options?: {
+    alt?: string;
+    caption?: string;
+    contentType?: string;
+  }): Promise<MediaItem>;
+  /** Delete a media item */
+  mediaDelete(id: string): Promise<void>;
+  /** Full-text search */
+  search(query: string, options?: {
+    collection?: string;
+    locale?: string;
+    limit?: number;
+  }): Promise<SearchResult[]>;
+  /** List taxonomies */
+  taxonomies(): Promise<Taxonomy[]>;
+  /** List terms in a taxonomy */
+  terms(taxonomy: string, options?: {
+    limit?: number;
+    cursor?: string;
+  }): Promise<ListResult<Term>>;
+  /** Create a taxonomy term */
+  createTerm(taxonomy: string, input: {
+    slug: string;
+    label: string;
+    parentId?: string;
+    description?: string;
+  }): Promise<Term>;
+  /** List menus */
+  menus(): Promise<Menu[]>;
+  /** Get a menu with its items */
+  menu(name: string): Promise<MenuWithItems>;
+  /** Make a typed JSON request to the API */
+  private request;
+  /** Make a raw request — caller handles response */
+  private requestRaw;
+  /** Assert a response is OK, throw typed error if not */
+  private assertOk;
+  /** Get cached field schemas for a collection, fetching if needed */
+  private getFieldSchemas;
+}
+//#endregion
+export { ApiError, ClientResponse, Collection, CollectionWithFields, ContentItem, DinewayApiError, DinewayClient, DinewayClientError, DinewayClientOptions, Field, type Interceptor, ListResult, Manifest, MediaItem, Menu, MenuItem, MenuWithItems, type PortableTextBlock, SchemaExport, SearchResult, Taxonomy, Term, createTransport, csrfInterceptor, devBypassInterceptor, markdownToPortableText, portableTextToMarkdown, tokenInterceptor };