@mymehq/sdk 1.0.0 → 2.0.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ConflictSnapshot, ItemState, CreateItemInput, Item, PaginatedResult, ItemWithMetadata, Version, Metadata, SearchResult, Thread, TypeSchema, CreateKeyInput, ApiKey, CreateWebhookInput, Webhook, UpdateWebhookInput, WebhookDelivery } from '@mymehq/shared';
+import { ConflictSnapshot, ItemState, CreateItemInput, Item, PaginatedResult, ItemWithMetadata, Version, Edge, Metadata, SearchResult, Thread, CreateEdgeInput, EdgeTypeSchema, TypeSchema, CreateKeyInput, ApiKey, CreateWebhookInput, Webhook, UpdateWebhookInput, WebhookDelivery, TenantConfig } from '@mymehq/shared';
 export { ApiKey, ConflictSnapshot, CreateItemInput, CreateKeyInput, Item, ItemState, Metadata, PaginatedResult, SearchResult, Thread, TypeSchema, Version } from '@mymehq/shared';
 
 /**
@@ -36,7 +36,6 @@ interface ClientConfig {
 }
 interface UpdateOptions {
     version?: number;
-    thread_id?: string | null;
     /**
      * Override the client's default conflict strategy for this update.
      * - `"auto"`: auto-merge non-conflicting fields (default)
@@ -51,9 +50,21 @@ interface ListFilters {
     type?: string;
     state?: ItemState;
     source?: string;
+    /** Filter to items whose parent-of source is this id. Kept as a
+     *  server-side convenience alias after the parent_id column was
+     *  dropped in Wave 2 PR 4; the server translates it into an
+     *  `edge[parent-of]` existence check. */
     parent_id?: string;
+    /** Filter to items in this thread. Server translates to
+     *  `edge[in-thread]` check after the thread_id column was dropped. */
     thread_id?: string;
     root_only?: boolean;
+    /** When set, restricts the result to library items (true) or ambient
+     * items (false). Per V0 spec, the default unrestricted view returns
+     * library items only on a fresh /items query — the explicit filter
+     * here lets callers opt into the ambient slice or be explicit about
+     * the library slice. */
+    library?: boolean;
     tags?: string[];
     filter?: string;
     sort?: "created_at" | "updated_at" | "timestamp";
@@ -71,7 +82,6 @@ interface SearchFilters {
 }
 interface MetadataInput {
     tags?: string[];
-    about?: string[];
 }
 declare class MymeClient {
     private readonly transport;
@@ -80,16 +90,36 @@ declare class MymeClient {
     private readonly cdnBaseUrl?;
     constructor(config: ClientConfig);
     readonly items: {
-        create: (input: CreateItemInput) => Promise<Item>;
+        create: (input: CreateItemInput & {
+            /** Atomic edges payload: for each edge type, listed ids become
+             *  targets with the new item as source. Replaces legacy parent_id
+             *  / thread_id / about which were dropped in Wave 2 PR 4. */
+            edges?: Record<string, string[]>;
+        }) => Promise<Item>;
         get: (id: string) => Promise<Item>;
         list: (filters?: ListFilters) => Promise<PaginatedResult<Item>>;
         listWithMetadata: (filters?: Omit<ListFilters, "include">) => Promise<PaginatedResult<ItemWithMetadata>>;
         update: (id: string, properties: Record<string, unknown>, options?: UpdateOptions) => Promise<Item>;
         delete: (id: string) => Promise<void>;
+        /** Permanently delete a trashed item (admin only). Item must already
+         * be in state "trashed"; returns 400 otherwise. Irreversible. */
+        purge: (id: string) => Promise<void>;
         restore: (id: string) => Promise<Item>;
         transition: (id: string, state: string) => Promise<Item>;
         versions: (id: string) => Promise<Version[]>;
         stats: () => Promise<Record<string, number>>;
+        /** Outbound edges from this item. Shortcut for edges.listFromSource. */
+        edges: (itemId: string, filters?: {
+            edge_type?: string | string[];
+            limit?: number;
+            cursor?: string;
+        }) => Promise<PaginatedResult<Edge>>;
+        /** Inbound edges targeting this item. Shortcut for edges.listToTarget. */
+        backrefs: (itemId: string, filters?: {
+            edge_type?: string | string[];
+            limit?: number;
+            cursor?: string;
+        }) => Promise<PaginatedResult<Edge>>;
     };
     readonly metadata: {
         get: (itemId: string) => Promise<Metadata>;
@@ -115,6 +145,34 @@ declare class MymeClient {
         addItem: (threadId: string, itemId: string) => Promise<Item>;
         removeItem: (threadId: string, itemId: string) => Promise<Item>;
     };
+    readonly edges: {
+        /** Create a single edge. Server enforces cardinality / type
+         *  constraints / cycle prevention; throws on violation. */
+        create: (input: CreateEdgeInput) => Promise<Edge>;
+        /** Update properties on an existing edge. edge_type / source / target
+         *  are immutable; server rejects with 400. */
+        update: (id: string, properties: Record<string, unknown>) => Promise<Edge>;
+        delete: (id: string) => Promise<void>;
+        /** Outbound edges — items where this id is source. Filter by edge type
+         *  (comma-separated string or array of type ids). */
+        listFromSource: (sourceId: string, filters?: {
+            edge_type?: string | string[];
+            limit?: number;
+            cursor?: string;
+        }) => Promise<PaginatedResult<Edge>>;
+        /** Inbound edges — items where this id is target. */
+        listToTarget: (targetId: string, filters?: {
+            edge_type?: string | string[];
+            limit?: number;
+            cursor?: string;
+        }) => Promise<PaginatedResult<Edge>>;
+        /** Custom edge-type registration + listing. */
+        types: {
+            create: (schema: EdgeTypeSchema) => Promise<EdgeTypeSchema>;
+            list: () => Promise<EdgeTypeSchema[]>;
+            delete: (id: string) => Promise<void>;
+        };
+    };
     readonly blobs: {
         upload: (data: Uint8Array | ArrayBuffer, mimeType: string) => Promise<{
             hash: string;
@@ -135,8 +193,13 @@ declare class MymeClient {
         }) => Promise<void>;
     };
     readonly keys: {
-        create: (input: CreateKeyInput) => Promise<{
-            id: string;
+        /** Creates an API key. The raw key value is returned exactly once on
+         * creation; the rest of the shape mirrors the persisted ApiKey record
+         * (source, default_origin, default_library, type_permissions, and
+         * extension_permissions are all stamped at create time and visible
+         * here so the caller doesn't need a follow-up GET /keys to inspect
+         * them). */
+        create: (input: CreateKeyInput) => Promise<ApiKey & {
             key: string;
         }>;
         list: () => Promise<ApiKey[]>;
@@ -152,6 +215,17 @@ declare class MymeClient {
             limit?: number;
         }) => Promise<WebhookDelivery[]>;
     };
+    /** Tenant-scoped configuration (per-type ambient retention overrides
+     * today; future tenant-level settings will live here). All endpoints
+     * are admin-only. */
+    readonly tenants: {
+        /** Returns the current tenant's config. Empty object when nothing
+         * is configured. */
+        getConfig: () => Promise<TenantConfig>;
+        /** Replaces the current tenant's config. Server validates that any
+         * type IDs in retention overrides resolve in the registry. */
+        setConfig: (config: TenantConfig) => Promise<TenantConfig>;
+    };
     private throwRawError;
 }
 

package/dist/index.js

@@ -118,7 +118,12 @@ var HttpTransport = class {
     if (!query) return url;
     const params = new URLSearchParams();
     for (const [key, value] of Object.entries(query)) {
-      if (value !== void 0) {
+      if (value === void 0) continue;
+      if (Array.isArray(value)) {
+        params.set(key, value.join(","));
+      } else if (typeof value === "boolean") {
+        params.set(key, value ? "true" : "false");
+      } else {
         params.set(key, String(value));
       }
     }
@@ -168,15 +173,14 @@ function toConflictError(response, clientPatch) {
     clientPatch
   );
 }
-async function handleConflictUpdate(transport, itemId, clientPatch, version, strategy, resolver, threadId) {
+async function handleConflictUpdate(transport, itemId, clientPatch, version, strategy, resolver) {
   let properties = clientPatch;
   let currentVersion = version;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     const result = await transport.requestWithConflict("PATCH", `/items/${itemId}`, {
       body: {
         properties,
-        version: currentVersion,
-        ...threadId !== void 0 && { thread_id: threadId }
+        version: currentVersion
       }
     });
     if (!isConflictResponse(result)) {
@@ -276,13 +280,20 @@ var MymeClient = class {
         properties,
         version,
         strategy,
-        options?.resolve,
-        options?.thread_id
+        options?.resolve
       );
     },
     delete: async (id) => {
       await this.transport.request("DELETE", `/items/${id}`);
     },
+    /** Permanently delete a trashed item (admin only). Item must already
+     * be in state "trashed"; returns 400 otherwise. Irreversible. */
+    purge: async (id) => {
+      await this.transport.request(
+        "DELETE",
+        `/items/${id}/purge`
+      );
+    },
     restore: async (id) => {
       const res = await this.transport.request(
         "POST",
@@ -310,7 +321,11 @@ var MymeClient = class {
         "GET",
         "/items/stats"
       );
-    }
+    },
+    /** Outbound edges from this item. Shortcut for edges.listFromSource. */
+    edges: (itemId, filters) => this.edges.listFromSource(itemId, filters),
+    /** Inbound edges targeting this item. Shortcut for edges.listToTarget. */
+    backrefs: (itemId, filters) => this.edges.listToTarget(itemId, filters)
   };
   // ---- Metadata ----
   metadata = {
@@ -424,6 +439,80 @@ var MymeClient = class {
       return res.item;
     }
   };
+  // ---- Edges ----
+  edges = {
+    /** Create a single edge. Server enforces cardinality / type
+     *  constraints / cycle prevention; throws on violation. */
+    create: async (input) => {
+      const res = await this.transport.request(
+        "POST",
+        "/edges",
+        { body: input }
+      );
+      return res.edge;
+    },
+    /** Update properties on an existing edge. edge_type / source / target
+     *  are immutable; server rejects with 400. */
+    update: async (id, properties) => {
+      const res = await this.transport.request(
+        "PATCH",
+        `/edges/${id}`,
+        { body: { properties } }
+      );
+      return res.edge;
+    },
+    delete: async (id) => {
+      await this.transport.request("DELETE", `/edges/${id}`);
+    },
+    /** Outbound edges — items where this id is source. Filter by edge type
+     *  (comma-separated string or array of type ids). */
+    listFromSource: async (sourceId, filters) => {
+      const edgeType = Array.isArray(filters?.edge_type) ? filters.edge_type.join(",") : filters?.edge_type;
+      return this.transport.request(
+        "GET",
+        `/items/${sourceId}/edges`,
+        {
+          query: {
+            ...edgeType && { edge_type: edgeType },
+            ...filters?.limit !== void 0 && { limit: filters.limit },
+            ...filters?.cursor && { cursor: filters.cursor }
+          }
+        }
+      );
+    },
+    /** Inbound edges — items where this id is target. */
+    listToTarget: async (targetId, filters) => {
+      const edgeType = Array.isArray(filters?.edge_type) ? filters.edge_type.join(",") : filters?.edge_type;
+      return this.transport.request(
+        "GET",
+        `/items/${targetId}/backrefs`,
+        {
+          query: {
+            ...edgeType && { edge_type: edgeType },
+            ...filters?.limit !== void 0 && { limit: filters.limit },
+            ...filters?.cursor && { cursor: filters.cursor }
+          }
+        }
+      );
+    },
+    /** Custom edge-type registration + listing. */
+    types: {
+      create: async (schema) => {
+        const res = await this.transport.request("POST", "/edges/types", { body: schema });
+        return res.edge_type;
+      },
+      list: async () => {
+        const res = await this.transport.request("GET", "/edges/types");
+        return res.edge_types;
+      },
+      delete: async (id) => {
+        await this.transport.request(
+          "DELETE",
+          `/edges/types/${id}`
+        );
+      }
+    }
+  };
   // ---- Blobs ----
   blobs = {
     upload: async (data, mimeType) => {
@@ -491,9 +580,16 @@ var MymeClient = class {
   };
   // ---- Keys ----
   keys = {
+    /** Creates an API key. The raw key value is returned exactly once on
+     * creation; the rest of the shape mirrors the persisted ApiKey record
+     * (source, default_origin, default_library, type_permissions, and
+     * extension_permissions are all stamped at create time and visible
+     * here so the caller doesn't need a follow-up GET /keys to inspect
+     * them). */
     create: async (input) => {
-      const res = await this.transport.request("POST", "/keys", { body: input });
-      return { id: res.id, key: res.key };
+      return this.transport.request("POST", "/keys", {
+        body: input
+      });
     },
     list: async () => {
       const res = await this.transport.request(
@@ -540,6 +636,29 @@ var MymeClient = class {
       return res.deliveries;
     }
   };
+  // ---- Tenants (admin) ----
+  /** Tenant-scoped configuration (per-type ambient retention overrides
+   * today; future tenant-level settings will live here). All endpoints
+   * are admin-only. */
+  tenants = {
+    /** Returns the current tenant's config. Empty object when nothing
+     * is configured. */
+    getConfig: async () => {
+      return this.transport.request(
+        "GET",
+        "/tenants/current/config"
+      );
+    },
+    /** Replaces the current tenant's config. Server validates that any
+     * type IDs in retention overrides resolve in the registry. */
+    setConfig: async (config) => {
+      return this.transport.request(
+        "PUT",
+        "/tenants/current/config",
+        { body: config }
+      );
+    }
+  };
   // ---- Internal ----
   throwRawError(status, body) {
     const parsed = body;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mymehq/sdk",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "type": "module",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",