zinkee 0.1.0

package/src/api/displays.ts

@@ -0,0 +1,276 @@
+import { ApiClient } from "../client.js";
+import type { NormalizedUuidOrSlug } from "../parsers/selectors.js";
+
+export interface ApiDisplay {
+  [key: string]: unknown;
+  id?: string;
+  name?: string;
+  layoutTemplate?: string;
+  layout?: {
+    template?: string;
+    freeformLayouts?: unknown;
+    slots?: Array<Record<string, unknown>>;
+    tabs?: Array<Record<string, unknown>>;
+  };
+  variables?: Array<Record<string, unknown>>;
+  widgets?: Array<Record<string, unknown>>;
+  navigationTargets?: Array<Record<string, unknown>>;
+  crossWidgetFilter?: Record<string, unknown> | null;
+}
+
+export interface ApiDisplayTab {
+  [key: string]: unknown;
+  id?: string;
+  name?: string;
+  orientation?: string;
+}
+
+export interface ApiDisplayVariable {
+  [key: string]: unknown;
+  id?: string;
+  name?: string;
+  type?: string;
+}
+
+export interface ApiDisplayWidget {
+  [key: string]: unknown;
+  id?: string;
+  name?: string;
+  type?: string;
+}
+
+export interface ApiDisplayNavigationTarget {
+  [key: string]: unknown;
+  id?: string;
+  label?: string;
+}
+
+export type DisplaySummary = ApiDisplay;
+export type DisplayResource = ApiDisplay;
+
+function jsonOptions(body: unknown, method: string): RequestInit {
+  return {
+    method,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(body),
+  };
+}
+
+function selectorValue(selector: NormalizedUuidOrSlug): string {
+  return encodeURIComponent(selector.value);
+}
+
+function segment(value: string): string {
+  return encodeURIComponent(value);
+}
+
+export class DisplaysApi {
+  constructor(private readonly client: ApiClient) {}
+
+  listDisplays(): Promise<ApiDisplay[]> {
+    return this.client.getJson<ApiDisplay[]>("/api/v2/displays");
+  }
+
+  getDisplay(display: NormalizedUuidOrSlug): Promise<ApiDisplay> {
+    return this.client.getJson<ApiDisplay>(`/api/v2/displays/${selectorValue(display)}`);
+  }
+
+  createDisplay(body: Record<string, unknown>): Promise<ApiDisplay> {
+    return this.client.requestJson<ApiDisplay>("/api/v2/displays", jsonOptions(body, "POST"));
+  }
+
+  updateDisplay(
+    display: NormalizedUuidOrSlug,
+    body: Record<string, unknown>,
+  ): Promise<ApiDisplay> {
+    return this.client.requestJson<ApiDisplay>(
+      `/api/v2/displays/${selectorValue(display)}`,
+      jsonOptions(body, "PATCH"),
+    );
+  }
+
+  deleteDisplay(display: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  getLayout(display: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
+    return this.client.getJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}/layout`,
+    );
+  }
+
+  patchLayout(
+    display: NormalizedUuidOrSlug,
+    body: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}/layout`,
+      jsonOptions(body, "PATCH"),
+    );
+  }
+
+  listTabs(display: NormalizedUuidOrSlug): Promise<ApiDisplayTab[]> {
+    return this.client.getJson<ApiDisplayTab[]>(
+      `/api/v2/displays/${selectorValue(display)}/tabs`,
+    );
+  }
+
+  createTab(
+    display: NormalizedUuidOrSlug,
+    body: Record<string, unknown>,
+  ): Promise<ApiDisplayTab> {
+    return this.client.requestJson<ApiDisplayTab>(
+      `/api/v2/displays/${selectorValue(display)}/tabs`,
+      jsonOptions(body, "POST"),
+    );
+  }
+
+  updateTab(
+    display: NormalizedUuidOrSlug,
+    tabId: string,
+    body: Record<string, unknown>,
+  ): Promise<ApiDisplayTab> {
+    return this.client.requestJson<ApiDisplayTab>(
+      `/api/v2/displays/${selectorValue(display)}/tabs/${segment(tabId)}`,
+      jsonOptions(body, "PATCH"),
+    );
+  }
+
+  deleteTab(display: NormalizedUuidOrSlug, tabId: string): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}/tabs/${segment(tabId)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  listVariables(display: NormalizedUuidOrSlug): Promise<ApiDisplayVariable[]> {
+    return this.client.getJson<ApiDisplayVariable[]>(
+      `/api/v2/displays/${selectorValue(display)}/variables`,
+    );
+  }
+
+  getVariable(display: NormalizedUuidOrSlug, variableId: string): Promise<ApiDisplayVariable> {
+    return this.client.getJson<ApiDisplayVariable>(
+      `/api/v2/displays/${selectorValue(display)}/variables/${segment(variableId)}`,
+    );
+  }
+
+  createVariable(
+    display: NormalizedUuidOrSlug,
+    body: Record<string, unknown>,
+  ): Promise<ApiDisplayVariable> {
+    return this.client.requestJson<ApiDisplayVariable>(
+      `/api/v2/displays/${selectorValue(display)}/variables`,
+      jsonOptions(body, "POST"),
+    );
+  }
+
+  updateVariable(display: NormalizedUuidOrSlug, variableId: string, body: Record<string, unknown>): Promise<ApiDisplayVariable> {
+    return this.client.requestJson<ApiDisplayVariable>(
+      `/api/v2/displays/${selectorValue(display)}/variables/${segment(variableId)}`,
+      jsonOptions(body, "PATCH"),
+    );
+  }
+
+  deleteVariable(display: NormalizedUuidOrSlug, variableId: string): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}/variables/${segment(variableId)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  listWidgets(display: NormalizedUuidOrSlug): Promise<ApiDisplayWidget[]> {
+    return this.client.getJson<ApiDisplayWidget[]>(
+      `/api/v2/displays/${selectorValue(display)}/widgets`,
+    );
+  }
+
+  getWidget(display: NormalizedUuidOrSlug, widgetId: string): Promise<ApiDisplayWidget> {
+    return this.client.getJson<ApiDisplayWidget>(
+      `/api/v2/displays/${selectorValue(display)}/widgets/${segment(widgetId)}`,
+    );
+  }
+
+  createWidget(
+    display: NormalizedUuidOrSlug,
+    body: Record<string, unknown>,
+  ): Promise<ApiDisplayWidget> {
+    return this.client.requestJson<ApiDisplayWidget>(
+      `/api/v2/displays/${selectorValue(display)}/widgets`,
+      jsonOptions(body, "POST"),
+    );
+  }
+
+  updateWidget(display: NormalizedUuidOrSlug, widgetId: string, body: Record<string, unknown>): Promise<ApiDisplayWidget> {
+    return this.client.requestJson<ApiDisplayWidget>(
+      `/api/v2/displays/${selectorValue(display)}/widgets/${segment(widgetId)}`,
+      jsonOptions(body, "PATCH"),
+    );
+  }
+
+  deleteWidget(display: NormalizedUuidOrSlug, widgetId: string): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}/widgets/${segment(widgetId)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  createNavigationTarget(
+    display: NormalizedUuidOrSlug,
+    body: Record<string, unknown>,
+  ): Promise<ApiDisplayNavigationTarget> {
+    return this.client.requestJson<ApiDisplayNavigationTarget>(
+      `/api/v2/displays/${selectorValue(display)}/navigation-targets`,
+      jsonOptions(body, "POST"),
+    );
+  }
+
+  updateNavigationTarget(
+    display: NormalizedUuidOrSlug,
+    targetId: string,
+    body: Record<string, unknown>,
+  ): Promise<ApiDisplayNavigationTarget> {
+    return this.client.requestJson<ApiDisplayNavigationTarget>(
+      `/api/v2/displays/${selectorValue(display)}/navigation-targets/${segment(targetId)}`,
+      jsonOptions(body, "PATCH"),
+    );
+  }
+
+  deleteNavigationTarget(
+    display: NormalizedUuidOrSlug,
+    targetId: string,
+  ): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}/navigation-targets/${segment(targetId)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  getCrossWidgetFilter(display: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
+    return this.client.getJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}/cross-widget-filter`,
+    );
+  }
+
+  setCrossWidgetFilter(
+    display: NormalizedUuidOrSlug,
+    body: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}/cross-widget-filter`,
+      jsonOptions(body, "PUT"),
+    );
+  }
+
+  deleteCrossWidgetFilter(display: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/displays/${selectorValue(display)}/cross-widget-filter`,
+      { method: "DELETE" },
+    );
+  }
+}

package/src/api/files.ts

@@ -0,0 +1,50 @@
+import { ApiClient } from "../client.js";
+import type { NormalizedUuidOrSlug } from "../parsers/selectors.js";
+
+export interface ApiFile {
+  [key: string]: unknown;
+  id?: string;
+  name?: string;
+  filename?: string;
+  size?: number;
+  mimeType?: string;
+}
+
+export interface FileStorageInfo {
+  [key: string]: unknown;
+  usedBytes?: number;
+  totalBytes?: number;
+  availableBytes?: number;
+  used?: number;
+  limitBytes?: number;
+}
+
+function selectorValue(selector: NormalizedUuidOrSlug): string {
+  return selector.value;
+}
+
+export class FilesApi {
+  constructor(private readonly client: ApiClient) {}
+
+  uploadFile(input: FormData): Promise<ApiFile> {
+    return this.client.requestJson<ApiFile>("/api/v2/files", {
+      method: "POST",
+      body: input,
+    });
+  }
+
+  downloadFile(file: NormalizedUuidOrSlug): Promise<ArrayBuffer> {
+    return this.client.requestBinary(`/api/v2/files/${selectorValue(file)}`);
+  }
+
+  deleteFile(file: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/files/${selectorValue(file)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  getStorageInfo(): Promise<FileStorageInfo> {
+    return this.client.getJson<FileStorageInfo>("/api/v2/files/storage-info");
+  }
+}

package/src/api/navigation.ts

@@ -0,0 +1,71 @@
+import { ApiClient } from "../client.js";
+import type { NormalizedUuidOrSlug } from "../parsers/selectors.js";
+
+export interface NavigationFolder {
+  id: string;
+  order?: number;
+  name?: string;
+  resources?: Array<Record<string, unknown>>;
+  additionalProperties?: Record<string, unknown>;
+}
+
+export interface NavigationFolderMutation {
+  folderId?: string;
+  name?: string;
+}
+
+export interface NavigationMoveResourceInput {
+  resourceId: string;
+  resourceType: string;
+  targetFolderId: string;
+}
+
+function jsonOptions(body: unknown, method: string): RequestInit {
+  return {
+    method,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(body),
+  };
+}
+
+function selectorValue(selector: NormalizedUuidOrSlug): string {
+  return selector.value;
+}
+
+export class NavigationApi {
+  constructor(private readonly client: ApiClient) {}
+
+  listFolders(): Promise<NavigationFolder[]> {
+    return this.client.getJson<NavigationFolder[]>("/api/v2/navigation/folders");
+  }
+
+  createFolder(body: Record<string, unknown>): Promise<NavigationFolderMutation> {
+    return this.client.requestJson<NavigationFolderMutation>(
+      "/api/v2/navigation/folders",
+      jsonOptions(body, "POST"),
+    );
+  }
+
+  updateFolder(folder: NormalizedUuidOrSlug, body: Record<string, unknown>): Promise<NavigationFolderMutation> {
+    return this.client.requestJson<NavigationFolderMutation>(
+      `/api/v2/navigation/folders/${selectorValue(folder)}`,
+      jsonOptions(body, "PATCH"),
+    );
+  }
+
+  deleteFolder(folder: NormalizedUuidOrSlug): Promise<NavigationFolderMutation> {
+    return this.client.requestJson<NavigationFolderMutation>(
+      `/api/v2/navigation/folders/${selectorValue(folder)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  moveResource(body: NavigationMoveResourceInput): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      "/api/v2/navigation/resources:move",
+      jsonOptions(body, "POST"),
+    );
+  }
+}

package/src/api/records.ts

@@ -0,0 +1,167 @@
+import { ApiClient } from "../client.js";
+import type { NormalizedUuidOrSlug } from "../parsers/selectors.js";
+
+export interface ApiRecord {
+  [key: string]: unknown;
+  recordId?: string;
+  values?: Record<string, unknown>;
+}
+
+export interface RecordQueryExpression {
+  field: string;
+  comparator: string;
+  value: unknown;
+}
+
+export interface RecordQuerySort {
+  field: string;
+  direction: "ASC" | "DESC";
+}
+
+export interface RecordQueryResult {
+  records: ApiRecord[];
+  page?: Record<string, unknown>;
+}
+
+export interface RecordQueryInput {
+  [key: string]: unknown;
+  select?: string[];
+  where?: RecordQueryExpression[];
+  sort?: string[];
+  limit?: number;
+  offset?: number;
+}
+
+export interface CreateRecordInput {
+  [key: string]: unknown;
+}
+
+export interface UpdateRecordInput {
+  [key: string]: unknown;
+  set?: Record<string, unknown>;
+  unset?: string[];
+}
+
+function jsonOptions(body: unknown, method: string): RequestInit {
+  return {
+    method,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(body),
+  };
+}
+
+function selectorValue(selector: NormalizedUuidOrSlug): string {
+  return selector.value;
+}
+
+export class RecordsApi {
+  constructor(private readonly client: ApiClient) {}
+
+  listRecords(
+    schema: NormalizedUuidOrSlug,
+    query: RecordQueryInput,
+  ): Promise<RecordQueryResult> {
+    const params = new URLSearchParams();
+
+    if (query.limit !== undefined) {
+      params.set("limit", String(query.limit));
+    }
+
+    if (query.offset !== undefined) {
+      params.set("offset", String(query.offset));
+    }
+
+    const path = `/api/v2/schemas/${selectorValue(schema)}/records`;
+    const queryString = params.toString();
+
+    return this.client.getJson<RecordQueryResult>(
+      queryString ? `${path}?${queryString}` : path,
+    );
+  }
+
+  queryRecords(
+    schema: NormalizedUuidOrSlug,
+    query: RecordQueryInput,
+  ): Promise<RecordQueryResult> {
+    const body = this.normalizeQueryInput(query);
+
+    return this.client.requestJson<RecordQueryResult>(
+      `/api/v2/schemas/${selectorValue(schema)}/records:query`,
+      jsonOptions(body, "POST"),
+    );
+  }
+
+  getRecord(
+    schema: NormalizedUuidOrSlug,
+    record: NormalizedUuidOrSlug,
+  ): Promise<ApiRecord> {
+    return this.client.getJson<ApiRecord>(
+      `/api/v2/schemas/${selectorValue(schema)}/records/${selectorValue(record)}`,
+    );
+  }
+
+  createRecord(
+    schema: NormalizedUuidOrSlug,
+    input: CreateRecordInput,
+  ): Promise<ApiRecord> {
+    return this.client.requestJson<ApiRecord>(
+      `/api/v2/schemas/${selectorValue(schema)}/records`,
+      jsonOptions(input, "POST"),
+    );
+  }
+
+  updateRecord(
+    schema: NormalizedUuidOrSlug,
+    record: NormalizedUuidOrSlug,
+    input: UpdateRecordInput,
+  ): Promise<ApiRecord> {
+    return this.client.requestJson<ApiRecord>(
+      `/api/v2/schemas/${selectorValue(schema)}/records/${selectorValue(record)}`,
+      jsonOptions(input, "PATCH"),
+    );
+  }
+
+  deleteRecord(
+    schema: NormalizedUuidOrSlug,
+    record: NormalizedUuidOrSlug,
+  ): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/schemas/${selectorValue(schema)}/records/${selectorValue(record)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  private normalizeQueryInput(query: RecordQueryInput): Record<string, unknown> {
+    const where = query.where?.map((expression) => ({
+      field: expression.field,
+      op: expression.comparator,
+      value: expression.value,
+    }));
+
+    const sort = query.sort?.map((entry) => {
+      const [field, direction = "asc"] = entry.split(":");
+      return {
+        field,
+        direction: direction.toUpperCase(),
+      };
+    });
+
+    return {
+      ...query,
+      select: query.select,
+      where,
+      sort,
+      page:
+        query.limit !== undefined || query.offset !== undefined
+          ? {
+              offset: query.offset,
+              limit: query.limit,
+            }
+          : undefined,
+      limit: undefined,
+      offset: undefined,
+    };
+  }
+}

package/src/api/schemas.ts

@@ -0,0 +1,130 @@
+import { ApiClient } from "../client.js";
+import type { NormalizedUuidOrSlug } from "../parsers/selectors.js";
+
+export interface ApiSchemaField {
+  [key: string]: unknown;
+  id?: string;
+  type?: string;
+  slug?: string;
+  label?: string;
+  required?: boolean;
+}
+
+export interface ApiSchema {
+  [key: string]: unknown;
+  id?: string;
+  name?: string;
+  slug?: string;
+  auditable?: boolean;
+  commentable?: boolean;
+  fields?: ApiSchemaField[];
+}
+
+export interface CreateSchemaInput {
+  name: string;
+  slug: string;
+  auditable?: boolean;
+  commentable?: boolean;
+}
+
+export interface UpdateSchemaInput {
+  name?: string;
+  slug?: string;
+  auditable?: boolean;
+  commentable?: boolean;
+}
+
+export interface CreateSchemaFieldInput {
+  [key: string]: unknown;
+  type: string;
+  slug: string;
+  label: string;
+  required?: boolean;
+}
+
+export interface UpdateSchemaFieldInput {
+  [key: string]: unknown;
+  label?: string;
+  required?: boolean;
+}
+
+function jsonOptions(body: unknown, method: string): RequestInit {
+  return {
+    method,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(body),
+  };
+}
+
+function selectorValue(selector: NormalizedUuidOrSlug): string {
+  return selector.value;
+}
+
+export class SchemasApi {
+  constructor(private readonly client: ApiClient) {}
+
+  listSchemas(): Promise<ApiSchema[]> {
+    return this.client.getJson<ApiSchema[]>("/api/v2/schemas");
+  }
+
+  getSchema(schema: NormalizedUuidOrSlug): Promise<ApiSchema> {
+    return this.client.getJson<ApiSchema>(`/api/v2/schemas/${selectorValue(schema)}`);
+  }
+
+  createSchema(input: CreateSchemaInput): Promise<ApiSchema> {
+    return this.client.requestJson<ApiSchema>("/api/v2/schemas", jsonOptions(input, "POST"));
+  }
+
+  updateSchema(schema: NormalizedUuidOrSlug, input: UpdateSchemaInput): Promise<ApiSchema> {
+    return this.client.requestJson<ApiSchema>(
+      `/api/v2/schemas/${selectorValue(schema)}`,
+      jsonOptions(input, "PATCH"),
+    );
+  }
+
+  deleteSchema(schema: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/schemas/${selectorValue(schema)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  async listFields(schema: NormalizedUuidOrSlug): Promise<ApiSchemaField[]> {
+    const result = await this.getSchema(schema);
+
+    return Array.isArray(result.fields) ? result.fields : [];
+  }
+
+  getField(schema: NormalizedUuidOrSlug, field: NormalizedUuidOrSlug): Promise<ApiSchemaField> {
+    return this.client.getJson<ApiSchemaField>(
+      `/api/v2/schemas/${selectorValue(schema)}/fields/${selectorValue(field)}`,
+    );
+  }
+
+  createField(schema: NormalizedUuidOrSlug, input: CreateSchemaFieldInput): Promise<ApiSchemaField> {
+    return this.client.requestJson<ApiSchemaField>(
+      `/api/v2/schemas/${selectorValue(schema)}/fields`,
+      jsonOptions(input, "POST"),
+    );
+  }
+
+  updateField(
+    schema: NormalizedUuidOrSlug,
+    field: NormalizedUuidOrSlug,
+    input: UpdateSchemaFieldInput,
+  ): Promise<ApiSchemaField> {
+    return this.client.requestJson<ApiSchemaField>(
+      `/api/v2/schemas/${selectorValue(schema)}/fields/${selectorValue(field)}`,
+      jsonOptions(input, "PATCH"),
+    );
+  }
+
+  deleteField(schema: NormalizedUuidOrSlug, field: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
+    return this.client.requestJson<Record<string, unknown>>(
+      `/api/v2/schemas/${selectorValue(schema)}/fields/${selectorValue(field)}`,
+      { method: "DELETE" },
+    );
+  }
+}