@storyblok/management-api-client 0.5.1 → 0.6.1

package/playground/integration-tests/test/types/resources.test-d.ts

@@ -0,0 +1,212 @@
+import { createManagementApiClient } from '@storyblok/management-api-client';
+import { describe, expectTypeOf, it } from 'vitest';
+
+const CLIENT_CONFIG = { personalAccessToken: 'test-token', spaceId: 12345 };
+
+describe('datasources type tests', () => {
+  it('should return datasource in response from create', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.datasources.create({
+      body: { datasource: { name: 'Test', slug: 'test' } },
+    });
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('datasource');
+    }
+  });
+
+  it('should return datasource in response from get', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.datasources.get(1);
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('datasource');
+    }
+  });
+
+  it('should return datasources array in response from list', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.datasources.list();
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('datasources');
+    }
+  });
+});
+
+describe('datasource entries type tests', () => {
+  it('should return datasource_entry in response from create', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.datasourceEntries.create({
+      body: { datasource_entry: { name: 'red', value: '#ff0000', datasource_id: 42 } },
+    });
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('datasource_entry');
+    }
+  });
+
+  it('should return datasource_entry in response from get', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.datasourceEntries.get(1);
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('datasource_entry');
+    }
+  });
+
+  it('should return datasource_entries array in response from list', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.datasourceEntries.list();
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('datasource_entries');
+    }
+  });
+});
+
+describe('asset folders type tests', () => {
+  it('should return asset_folder in response from create', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.assetFolders.create({
+      body: { asset_folder: { name: 'Photos' } },
+    });
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('asset_folder');
+    }
+  });
+
+  it('should return asset_folder in response from get', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.assetFolders.get(1);
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('asset_folder');
+    }
+  });
+
+  it('should return asset_folders array in response from list', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.assetFolders.list();
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('asset_folders');
+    }
+  });
+});
+
+describe('component folders type tests', () => {
+  it('should return component_group in response from create', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.componentFolders.create({
+      body: { component_group: { name: 'Layout' } },
+    });
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('component_group');
+    }
+  });
+
+  it('should return component_group in response from get', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.componentFolders.get(1);
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('component_group');
+    }
+  });
+
+  it('should return component_groups array in response from list', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.componentFolders.list();
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('component_groups');
+    }
+  });
+});
+
+describe('internal tags type tests', () => {
+  it('should return internal_tag in response from create', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.internalTags.create({
+      body: { internal_tag: { name: 'hero' } },
+    });
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('internal_tag');
+    }
+  });
+
+  it('should return internal_tags array in response from list', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.internalTags.list();
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('internal_tags');
+    }
+  });
+});
+
+describe('presets type tests', () => {
+  it('should return preset in response from create', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.presets.create({
+      body: { preset: { name: 'Hero Dark', component_id: 42 } },
+    });
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('preset');
+    }
+  });
+
+  it('should return preset in response from get', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.presets.get(1);
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('preset');
+    }
+  });
+
+  it('should return presets array in response from list', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.presets.list();
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('presets');
+    }
+  });
+});
+
+describe('spaces type tests', () => {
+  it('should return space in response from create', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.spaces.create({
+      body: { space: { name: 'Test Space' } },
+    });
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('space');
+    }
+  });
+
+  it('should return space in response from get', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.spaces.get();
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('space');
+    }
+  });
+
+  it('should return spaces array in response from list', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.spaces.list();
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('spaces');
+    }
+  });
+});
+
+describe('users type tests', () => {
+  it('should return user in response from updateMe', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.users.updateMe({
+      body: { user: { firstname: 'Jane' } },
+    });
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('user');
+    }
+  });
+
+  it('should return user in response from me', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.users.me();
+    if (result.data) {
+      expectTypeOf(result.data).toHaveProperty('user');
+    }
+  });
+});

package/playground/integration-tests/test/types/stories.test-d.ts

@@ -0,0 +1,310 @@
+import { defineBlock, defineField, defineSchema, type Schema as InferSchema } from '@storyblok/schema';
+import { storyblokColorField } from '@storyblok/schema/field-plugins';
+import { createManagementApiClient, type PluginFieldValue, type Story as StoryMapi } from '@storyblok/management-api-client';
+import { describe, expectTypeOf, it } from 'vitest';
+
+// Nestable block — not a root story type
+const teaserComponent = defineBlock({
+  name: 'teaser',
+  fields: [
+    defineField('text', { type: 'text' }),
+    defineField('image', { type: 'asset' }),
+  ],
+  id: 0,
+  created_at: '',
+  updated_at: '',
+});
+
+// Root content type that is also nestable (can appear as both a story and inside bloks)
+const heroComponent = defineBlock({
+  name: 'hero',
+  is_root: true,
+  fields: [
+    defineField('title', { type: 'text' }),
+    defineField('count', { type: 'number' }),
+    // bloks field without a whitelist — resolves to nestable components only
+    defineField('sections', { type: 'bloks' }),
+  ],
+  id: 0,
+  created_at: '',
+  updated_at: '',
+});
+
+// Root content type, not nestable
+const _pageComponent = defineBlock({
+  name: 'page',
+  is_root: true,
+  is_nestable: false,
+  fields: [
+    defineField('headline', { type: 'text' }),
+    defineField('body', { type: 'richtext' }),
+    defineField('teasers', { type: 'bloks', allow: [teaserComponent.name] }),
+    defineField('hero', { type: 'bloks', allow: [heroComponent.name] }),
+    defineField('blocks', { type: 'bloks', allow: [heroComponent.name, teaserComponent.name] }),
+  ],
+  id: 0,
+  created_at: '',
+  updated_at: '',
+});
+
+const CLIENT_CONFIG = { personalAccessToken: 'test-token', spaceId: 12345 };
+
+interface StoryblokTypes {
+  components: typeof _pageComponent | typeof heroComponent | typeof teaserComponent;
+}
+
+describe('createManagementApiClient without .withTypes()', () => {
+  it('should return StoryMapi from stories.get()', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.stories.get(123);
+    if (result.data) {
+      expectTypeOf(result.data.story).toEqualTypeOf<StoryMapi | undefined>();
+    }
+  });
+
+  it('should return StoryMapi array from stories.list()', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG);
+    const result = await client.stories.list();
+    if (result.data) {
+      expectTypeOf(result.data.stories).toEqualTypeOf<StoryMapi[] | undefined>();
+    }
+  });
+
+  it('should infer ThrowOnError from config without .withTypes()', async () => {
+    const client = createManagementApiClient({ ...CLIENT_CONFIG, throwOnError: true });
+    const result = await client.stories.get(123);
+    // ThrowOnError=true means data is always defined (no optional chaining needed)
+    expectTypeOf(result.data.story).toEqualTypeOf<StoryMapi | undefined>();
+  });
+
+  it('should allow per-call throwOnError override to false', async () => {
+    const client = createManagementApiClient({ ...CLIENT_CONFIG, throwOnError: true });
+    const result = await client.stories.get(123, { throwOnError: false });
+    if (result.data) {
+      expectTypeOf(result.data.story).toEqualTypeOf<StoryMapi | undefined>();
+    }
+  });
+});
+
+describe('createManagementApiClient with .withTypes()', () => {
+  it('should narrow page content fields after component discriminant check on get()', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    const result = await client.stories.get(123);
+    if (result.data?.story) {
+      const story = result.data.story;
+      if (story.content.component === 'page') {
+        expectTypeOf(story.content.headline).toEqualTypeOf<string | null | undefined>();
+        expectTypeOf(story.content.component).toEqualTypeOf<'page'>();
+      }
+    }
+  });
+
+  it('should narrow hero content fields after component discriminant check on get()', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    const result = await client.stories.get(123);
+    if (result.data?.story) {
+      const story = result.data.story;
+      if (story.content.component === 'hero') {
+        expectTypeOf(story.content.title).toEqualTypeOf<string | null | undefined>();
+        expectTypeOf(story.content.count).toEqualTypeOf<number | null | undefined>();
+        expectTypeOf(story.content.component).toEqualTypeOf<'hero'>();
+      }
+    }
+  });
+
+  it('should have union of literal component names on content', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    const result = await client.stories.get(123);
+    if (result.data?.story) {
+      // Only root components (is_root: true) appear in story content
+      expectTypeOf(result.data.story.content.component).toEqualTypeOf<'page' | 'hero'>();
+    }
+  });
+
+  it('should narrow discriminated union in stories.list()', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    const result = await client.stories.list();
+    if (result.data?.stories) {
+      for (const story of result.data.stories) {
+        if (story.content.component === 'page') {
+          expectTypeOf(story.content.headline).toEqualTypeOf<string | null | undefined>();
+        }
+        if (story.content.component === 'hero') {
+          expectTypeOf(story.content.count).toEqualTypeOf<number | null | undefined>();
+        }
+      }
+    }
+  });
+
+  it('should narrow bloks field on page to whitelisted component names', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    const result = await client.stories.get(123);
+    if (result.data?.story) {
+      const story = result.data.story;
+      if (story.content.component === 'page') {
+        if (story.content.teasers) {
+          for (const teaser of story.content.teasers) {
+            expectTypeOf(teaser.component).toEqualTypeOf<'teaser'>();
+            expectTypeOf(teaser.text).toEqualTypeOf<string | null | undefined>();
+          }
+        }
+        if (story.content.hero) {
+          for (const hero of story.content.hero) {
+            expectTypeOf(hero.component).toEqualTypeOf<'hero'>();
+            expectTypeOf(hero.count).toEqualTypeOf<number | null | undefined>();
+          }
+        }
+        if (story.content.blocks) {
+          for (const blok of story.content.blocks) {
+            // blocks whitelists both hero and teaser → union of the two
+            expectTypeOf(blok.component).toEqualTypeOf<'hero' | 'teaser'>();
+          }
+        }
+      }
+    }
+  });
+
+  it('should fall back to all schema components for bloks field without whitelist', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    const result = await client.stories.get(123);
+    if (result.data?.story) {
+      const story = result.data.story;
+      if (story.content.component === 'hero' && story.content.sections) {
+        // sections has no component_whitelist — falls back to nestable (is_nestable: true)
+        // components only; page has is_nestable: false, so it is excluded
+        type Sections = typeof story.content.sections;
+        expectTypeOf<Sections[number]['component']>().toEqualTypeOf<'hero' | 'teaser'>();
+      }
+    }
+  });
+
+  it('should infer ThrowOnError alongside .withTypes()', async () => {
+    const client = createManagementApiClient({ ...CLIENT_CONFIG, throwOnError: true }).withTypes<StoryblokTypes>();
+    const result = await client.stories.get(123);
+    if (result.data.story) {
+      // ThrowOnError=true keeps data defined; only root components appear in content
+      expectTypeOf(result.data.story.content.component).toEqualTypeOf<'page' | 'hero'>();
+    }
+  });
+
+  it('should allow per-call throwOnError override to false alongside .withTypes()', async () => {
+    const client = createManagementApiClient({ ...CLIENT_CONFIG, throwOnError: true }).withTypes<StoryblokTypes>();
+    const result = await client.stories.get(123, { throwOnError: false });
+    if (result.data?.story) {
+      expectTypeOf(result.data.story.content.component).toEqualTypeOf<'page' | 'hero'>();
+    }
+  });
+
+  it('should narrow story in create() response', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    const result = await client.stories.create({
+      body: { story: { name: 'My Page', content: { component: 'page' } } },
+    });
+    if (result.data?.story) {
+      const story = result.data.story;
+      if (story.content.component === 'page') {
+        expectTypeOf(story.content.headline).toEqualTypeOf<string | null | undefined>();
+      }
+    }
+  });
+
+  it('should narrow story in update() response', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    const result = await client.stories.update(123, {
+      body: { story: { content: { component: 'hero' } } },
+    });
+    if (result.data?.story) {
+      const story = result.data.story;
+      if (story.content.component === 'hero') {
+        expectTypeOf(story.content.title).toEqualTypeOf<string | null | undefined>();
+      }
+    }
+  });
+
+  it('should narrow create() body story.content to component union', async () => {
+    const _client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    type CreateBodyType = Parameters<typeof _client.stories.create>[0]['body'];
+    type CreateStoryContent = NonNullable<CreateBodyType['story']['content']>;
+    // The write payload's content discriminant is narrowed to root component names too
+    expectTypeOf<CreateStoryContent['component']>().toEqualTypeOf<'page' | 'hero'>();
+  });
+
+  it('should narrow update() body story.content to component union', async () => {
+    const _client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    type UpdateBodyType = Parameters<typeof _client.stories.update>[1]['body'];
+    type UpdateStoryContent = NonNullable<UpdateBodyType['story']['content']>;
+    // update() is the second positional arg (id, body); content discriminant is the root union
+    expectTypeOf<UpdateStoryContent['component']>().toEqualTypeOf<'page' | 'hero'>();
+  });
+});
+
+describe('withTypes() write-body narrowing', () => {
+  it('should reject nestable-only component name in create body content', () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    client.stories.create({
+      // @ts-expect-error: teaser is nestable-only, not a root component
+      body: { story: { name: 'Bad', content: { component: 'teaser' } } },
+    });
+  });
+
+  it('should reject wrong field value type in create body content', () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    client.stories.create({
+      body: { story: { name: 'Bad', content: {
+        component: 'page',
+        // @ts-expect-error: headline must be string, not number
+        headline: 123,
+      } } },
+    });
+  });
+
+  it('should return a typed story with content.component as discriminant from stories.get', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<StoryblokTypes>();
+    const result = await client.stories.get(123);
+
+    if (result.data?.story) {
+      const story = result.data.story;
+      expectTypeOf(story.content.component).toEqualTypeOf<'page' | 'hero'>();
+
+      if (story.content.component === 'page') {
+        expectTypeOf(story.content.headline).toEqualTypeOf<string | null | undefined>();
+      }
+    }
+  });
+});
+
+describe('createManagementApiClient with .withTypes() — field plugins', () => {
+  const _themedComponent = defineBlock({
+    name: 'themed',
+    is_root: true,
+    fields: [
+      defineField('bg', { type: 'custom', field_type: 'storyblok-colorpicker' }),
+      defineField('legacy', { type: 'custom', field_type: 'unregistered-plugin' }),
+    ],
+  });
+  const _schema = defineSchema({
+    blocks: { themedComponent: _themedComponent },
+    fieldPlugins: { storyblokColorField },
+  });
+  type Schema = InferSchema<typeof _schema>;
+
+  it('resolves a registered custom field to the validator output merged with the plugin envelope', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<Schema>();
+    const result = await client.stories.get(123);
+    if (result.data?.story && result.data.story.content.component === 'themed') {
+      expectTypeOf<NonNullable<typeof result.data.story.content.bg>>().toEqualTypeOf<{
+        color: string;
+        plugin: string;
+        _uid?: string;
+      }>();
+    }
+  });
+
+  it('leaves an unregistered custom field as PluginFieldValue', async () => {
+    const client = createManagementApiClient(CLIENT_CONFIG).withTypes<Schema>();
+    const result = await client.stories.get(123);
+    if (result.data?.story && result.data.story.content.component === 'themed') {
+      expectTypeOf<NonNullable<typeof result.data.story.content.legacy>>().toEqualTypeOf<PluginFieldValue>();
+    }
+  });
+});

package/playground/integration-tests/vitest.config.e2e.ts

@@ -0,0 +1,25 @@
+/// <reference types="vitest" />
+import { defineConfig } from 'vitest/config';
+
+/**
+ * Vitest config for end-to-end tests that hit the real Storyblok Management API.
+ *
+ * These tests are NOT run in CI. Trigger them manually:
+ *   pnpm --filter @storyblok/mapi-integration-tests test:e2e
+ *
+ * Prerequisites:
+ *   - A .env.qa-engineer-manual file at the repo root with STORYBLOK_TOKEN and STORYBLOK_SPACE_ID.
+ *   - The @storyblok/management-api-client package must be built.
+ */
+export default defineConfig({
+  test: {
+    include: ['./test/specs/**/*.spec.e2e.ts'],
+    setupFiles: ['./test/setup.e2e.ts'],
+    globals: true,
+    testTimeout: 60_000,
+    hookTimeout: 120_000,
+    sequence: {
+      concurrent: false,
+    },
+  },
+});

package/playground/integration-tests/vitest.config.ts

@@ -0,0 +1,13 @@
+/// <reference types="vitest" />
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: [],
+    typecheck: {
+      enabled: true,
+      include: ['./test/types/**/*.test-d.ts'],
+    },
+  },
+});

package/test/GUIDE.md

@@ -0,0 +1,59 @@
+# Manually Test the @storyblok/management-api-client Package
+
+`@storyblok/management-api-client` is the Management API (MAPI) client. The key things to validate manually are that the schema-aware `.withTypes()` integration correctly narrows story content, that every define helper produces a valid creation payload, and that Zod schemas accept real API responses.
+
+## Automated e2e tests
+
+The `@storyblok/mapi-integration-tests` package (`packages/mapi-client/playground/integration-tests`) covers the full round-trip against a real Storyblok space in `test/specs/mapi-round-trip.spec.e2e.ts`:
+
+- Seeds components, datasources, internal tags, presets, and stories via the MAPI.
+- Validates runtime values, type narrowing, nested bloks (two- and three-level), unwhitelisted bloks, and update round-trips.
+- Validates MAPI Zod schemas (`componentSchema`, `storySchema`, `datasourceSchema`, `datasourceEntrySchema`) against real API responses.
+
+Run manually:
+
+```bash
+pnpm --filter @storyblok/mapi-integration-tests test:e2e
+```
+
+### Prerequisites
+
+- A `.env.qa-engineer-manual` file at the repo root with `STORYBLOK_TOKEN` and `STORYBLOK_SPACE_ID`.
+- `@storyblok/management-api-client` must be built first.
+
+## Fetch via MAPI client and check content types
+
+`stories.get(storyId)` takes a numeric/string ID as its first positional argument — there is no `getBySlug`. Fetch the ID from `stories.list` first:
+
+```ts
+import { createManagementApiClient } from '@storyblok/management-api-client';
+
+const client = createManagementApiClient({ personalAccessToken: process.env.STORYBLOK_TOKEN, spaceId });
+const list = await client.stories.list({ query: { per_page: 100 } });
+const story = list.data?.stories?.find(s => s.slug === 'home');
+const result = await client.stories.get(story.id);
+console.info(result.data?.story?.content);
+```
+
+## Push component JSONs via the CLI
+
+To push `defineComponent` components, serialize the component objects to JSON and stage them under `.storyblok/components/<space_id>/`:
+
+```bash
+node packages/cli/dist/index.mjs components push \
+  --from qa-test \
+  --space $STORYBLOK_SPACE_ID \
+  --separate-files
+```
+
+**Always push components before stories.** The CLI validates that each story's `content.component` (and any nested block components) exist in the space. Pushing stories first fails if the referenced components are not yet present.
+
+You can do the same with stories. **Story filename convention:** the CLI requires files named `{slug}_{uuid}.json` where the part after the last `_` exactly matches `story.uuid` in the JSON. Use hyphens (not underscores) in UUIDs. A mismatch causes Pass 2 of the push (reference mapping + content update) to silently skip all stories.
+
+## Known quirks
+
+- **Stories require a content type component (`is_root: true`).** The MAPI rejects story creation with `"please select a content type component as your root component"` if the component used as the story root does not have `is_root: true`.
+- **MAPI `stories.get` takes a positional ID, not an options object:** `client.stories.get(id)` — there is no `getBySlug`. The `list` response does not include `content`; call `get(id)` for full content.
+- **MAPI client constructor uses `personalAccessToken`:** `createManagementApiClient({ personalAccessToken: '...', spaceId: ... })`.
+- **Delete methods are `delete`:** Use `client.RESOURCE.delete(id)`.
+- **Each story JSON must have a unique `id`.** If multiple story files share the same `id`, the CLI's manifest maps all of them to the same `old_id` entry, causing "slug already taken" errors.

package/vitest.config.ts

@@ -4,5 +4,10 @@ import { defineConfig } from 'vitest/config';
 export default defineConfig({
   test: {
     environment: 'node',
+    exclude: ['**/node_modules/**', '**/dist/**', './playground/**'],
+    typecheck: {
+      enabled: true,
+      exclude: ['**/node_modules/**', '**/dist/**', './playground/**'],
+    },
   },
 });

package/dist/generated/asset_folders/client.gen.cjs

@@ -1,10 +0,0 @@
-const require_utils_gen = require('../shared/client/utils.gen.cjs');
-const require_client_gen = require('../shared/client/client.gen.cjs');
-require('../shared/client/index.cjs');
-
-//#region src/generated/asset_folders/client.gen.ts
-const client = require_client_gen.createClient(require_utils_gen.createConfig({ baseUrl: "https://mapi.storyblok.com" }));
-
-//#endregion
-exports.client = client;
-//# sourceMappingURL=client.gen.cjs.map

package/dist/generated/asset_folders/client.gen.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.gen.cjs","names":["createClient","createConfig"],"sources":["../../../src/generated/asset_folders/client.gen.ts"],"sourcesContent":["// This file is auto-generated by @hey-api/openapi-ts\n\nimport { type ClientOptions, type Config, createClient, createConfig } from '../shared/client';\nimport type { ClientOptions as ClientOptions2 } from './types.gen';\n\n/**\n * The `createClientConfig()` function will be called on client initialization\n * and the returned object will become the client's initial configuration.\n *\n * You may want to initialize your client this way instead of calling\n * `setConfig()`. This is useful for example if you're using Next.js\n * to ensure your client always has the correct values.\n */\nexport type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;\n\nexport const client = createClient(createConfig<ClientOptions2>({ baseUrl: 'https://mapi.storyblok.com' }));\n"],"mappings":";;;;;AAeA,MAAa,SAASA,gCAAaC,+BAA6B,EAAE,SAAS,8BAA8B,CAAC,CAAC"}

package/dist/generated/asset_folders/client.gen.mjs

@@ -1,10 +0,0 @@
-import { createConfig } from "../shared/client/utils.gen.mjs";
-import { createClient } from "../shared/client/client.gen.mjs";
-import "../shared/client/index.mjs";
-
-//#region src/generated/asset_folders/client.gen.ts
-const client = createClient(createConfig({ baseUrl: "https://mapi.storyblok.com" }));
-
-//#endregion
-export { client };
-//# sourceMappingURL=client.gen.mjs.map

package/dist/generated/asset_folders/client.gen.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.gen.mjs","names":[],"sources":["../../../src/generated/asset_folders/client.gen.ts"],"sourcesContent":["// This file is auto-generated by @hey-api/openapi-ts\n\nimport { type ClientOptions, type Config, createClient, createConfig } from '../shared/client';\nimport type { ClientOptions as ClientOptions2 } from './types.gen';\n\n/**\n * The `createClientConfig()` function will be called on client initialization\n * and the returned object will become the client's initial configuration.\n *\n * You may want to initialize your client this way instead of calling\n * `setConfig()`. This is useful for example if you're using Next.js\n * to ensure your client always has the correct values.\n */\nexport type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;\n\nexport const client = createClient(createConfig<ClientOptions2>({ baseUrl: 'https://mapi.storyblok.com' }));\n"],"mappings":";;;;;AAeA,MAAa,SAAS,aAAa,aAA6B,EAAE,SAAS,8BAA8B,CAAC,CAAC"}