@mymehq/sdk 3.1.0 → 3.2.0

package/dist/index.d.ts

@@ -45,6 +45,9 @@ interface UpdateOptions {
     conflict?: ConflictStrategy;
     /** Custom conflict resolver (required when `conflict` is `"callback"`). */
     resolve?: ConflictResolver;
+    /** Toggle library / ambient state. Independent of the version-merge path
+     *  for `properties`; a library-only update never conflicts. */
+    library?: boolean;
 }
 interface ListFilters {
     type?: string;
@@ -71,6 +74,9 @@ interface SearchFilters {
     state?: ItemState;
     /** Tri-value library filter, matching `ListFilters.library`. */
     library?: boolean;
+    /** Items must have ALL specified tags (AND semantics). Matches
+     *  `ListFilters.tags` and `/items?tags=`. */
+    tags?: string[];
     filter?: string;
     limit?: number;
 }
@@ -120,12 +126,33 @@ declare class MymeClient {
         merge: (itemId: string, input: Partial<MetadataInput>) => Promise<Metadata>;
         addTags: (itemId: string, tags: string[]) => Promise<Metadata>;
         removeTag: (itemId: string, tag: string) => Promise<void>;
+        /**
+         * Enumerate the distinct set of tags in use across items the caller can
+         * read. Tenant-scoped, type-permission scoped, excludes trashed items.
+         * Returns tags with usage counts, sorted by count desc then tag asc.
+         */
+        listTags: () => Promise<{
+            tag: string;
+            count: number;
+        }[]>;
         getExtensions: (itemId: string, namespace?: string) => Promise<Record<string, Record<string, unknown>>>;
         setExtension: (itemId: string, namespace: string, data: Record<string, unknown>) => Promise<Record<string, Record<string, unknown>>>;
         deleteExtension: (itemId: string, namespace: string) => Promise<void>;
     };
     search(query: string, filters?: SearchFilters): Promise<SearchResult[]>;
     readonly edges: {
+        /**
+         * Global edge listing across the tenant, filtered by edge type
+         * (comma-separated string or array of type ids). Use this when you
+         * need "all edges of type X" — replaces the walk-every-item
+         * pattern. Per-target filters live on `listFromSource` /
+         * `listToTarget`.
+         */
+        list: (filters?: {
+            edge_type?: string | string[];
+            limit?: number;
+            cursor?: string;
+        }) => Promise<PaginatedResult<Edge>>;
         /** Create a single edge. Server enforces cardinality / type
          *  constraints / cycle prevention; throws on violation. */
         create: (input: CreateEdgeInput) => Promise<Edge>;

package/dist/index.js

@@ -173,14 +173,15 @@ function toConflictError(response, clientPatch) {
     clientPatch
   );
 }
-async function handleConflictUpdate(transport, itemId, clientPatch, version, strategy, resolver) {
+async function handleConflictUpdate(transport, itemId, clientPatch, version, strategy, resolver, library) {
   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
+        version: currentVersion,
+        ...library !== void 0 && { library }
       }
     });
     if (!isConflictResponse(result)) {
@@ -280,7 +281,8 @@ var MymeClient = class {
         properties,
         version,
         strategy,
-        options?.resolve
+        options?.resolve,
+        options?.library
       );
     },
     delete: async (id) => {
@@ -366,6 +368,15 @@ var MymeClient = class {
         `/items/${itemId}/tags/${encodeURIComponent(tag)}`
       );
     },
+    /**
+     * Enumerate the distinct set of tags in use across items the caller can
+     * read. Tenant-scoped, type-permission scoped, excludes trashed items.
+     * Returns tags with usage counts, sorted by count desc then tag asc.
+     */
+    listTags: async () => {
+      const res = await this.transport.request("GET", "/metadata/tags");
+      return res.tags;
+    },
     getExtensions: async (itemId, namespace) => {
       if (namespace) {
         const res2 = await this.transport.request(
@@ -403,6 +414,23 @@ var MymeClient = class {
   }
   // ---- Edges ----
   edges = {
+    /**
+     * Global edge listing across the tenant, filtered by edge type
+     * (comma-separated string or array of type ids). Use this when you
+     * need "all edges of type X" — replaces the walk-every-item
+     * pattern. Per-target filters live on `listFromSource` /
+     * `listToTarget`.
+     */
+    list: async (filters) => {
+      const edgeType = Array.isArray(filters?.edge_type) ? filters.edge_type.join(",") : filters?.edge_type;
+      return this.transport.request("GET", "/edges", {
+        query: {
+          ...edgeType && { edge_type: edgeType },
+          ...filters?.limit !== void 0 && { limit: filters.limit },
+          ...filters?.cursor && { cursor: filters.cursor }
+        }
+      });
+    },
     /** Create a single edge. Server enforces cardinality / type
      *  constraints / cycle prevention; throws on violation. */
     create: async (input) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mymehq/sdk",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "type": "module",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
@@ -16,7 +16,7 @@
     "dist"
   ],
   "dependencies": {
-    "@mymehq/shared": "3.1.0"
+    "@mymehq/shared": "3.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",