@studiocms/devapps 0.1.0-beta.9 → 0.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 StudioCMS - Adam Matthiesen, Jacob Jenkins, Paul Valladares
+Copyright (c) 2025-present StudioCMS - withstudiocms (https://github.com/withstudiocms)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,5 +1,7 @@
 # StudioCMS - Development Apps
 
+[![codecov](https://codecov.io/github/withstudiocms/studiocms/graph/badge.svg?token=RN8LT1O5E2&component=studiocms_devapps)](https://codecov.io/github/withstudiocms/studiocms)
+
 Collection* of useful tools available during dev mode in Astro
 
 ## Installation
@@ -50,28 +52,6 @@ export default defineConfig({
 
 All tools will only be available during `astro dev` and will not be available during production deployments!
 
-### libSQL Viewer
-
-#### Requires
-
-The following env variables set (`@astrojs/db`):
-- **`ASTRO_DB_REMOTE_URL`**
-- **`ASTRO_DB_APP_TOKEN`**
-
-#### Preview
-
-- Toolbar app
-
-![toolbar](./assets/preview-toolbar.png)
-
-- Toolbar app Embedded
-
-![toolbar-embedded](./assets/preview-embeddedapp.png)
-
-- Full page View
-
-![pageview](./assets/preview-page.png)
-
 ### WordPress Importer
 
 #### Requires
@@ -88,5 +68,5 @@ The following env variables set (`@astrojs/db`):
 
 ## Licensing
 
-[MIT Licensed](https://github.com/astrolicious/studiocms/blob/main/LICENSE).
+[MIT Licensed](./LICENSE).
 

package/dist/effects/WordPressAPI/configs.d.ts

@@ -0,0 +1,87 @@
+import type { APIContext } from 'astro';
+import { Context, Effect, Layer } from 'studiocms/effect';
+import type { PageData } from './importers.js';
+declare const StringConfig_base: Context.TagClass<StringConfig, "StringConfig", {
+    readonly str: string;
+}>;
+export declare class StringConfig extends StringConfig_base {
+    static makeLayer: (str: string) => Layer.Layer<StringConfig, never, never>;
+    static makeProvide: (str: string) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, StringConfig>>;
+}
+type APISupportedTypes = 'posts' | 'pages' | 'media' | 'categories' | 'tags' | 'settings';
+declare const APIEndpointConfig_base: Context.TagClass<APIEndpointConfig, "APIEndpointConfig", {
+    readonly endpoint: string;
+    readonly type: APISupportedTypes;
+    readonly path?: string | undefined;
+}>;
+export declare class APIEndpointConfig extends APIEndpointConfig_base {
+    static makeLayer: (endpoint: string, type: APISupportedTypes, path?: string) => Layer.Layer<APIEndpointConfig, never, never>;
+    static makeProvide: (endpoint: string, type: APISupportedTypes, path?: string) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, APIEndpointConfig>>;
+}
+declare const DownloadImageConfig_base: Context.TagClass<DownloadImageConfig, "DownloadImageConfig", {
+    readonly imageUrl: string | URL;
+    readonly destination: string | URL;
+}>;
+export declare class DownloadImageConfig extends DownloadImageConfig_base {
+    static makeLayer: (imageUrl: string | URL, destination: string | URL) => Layer.Layer<DownloadImageConfig, never, never>;
+    static makeProvide: (imageUrl: string | URL, destination: string | URL) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, DownloadImageConfig>>;
+}
+declare const DownloadPostImageConfig_base: Context.TagClass<DownloadPostImageConfig, "DownloadPostImageConfig", {
+    readonly str: string;
+    readonly pathToFolder: string;
+}>;
+export declare class DownloadPostImageConfig extends DownloadPostImageConfig_base {
+    static makeLayer: (str: string, pathToFolder: string) => Layer.Layer<DownloadPostImageConfig, never, never>;
+    static makeProvide: (str: string, pathToFolder: string) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, DownloadPostImageConfig>>;
+}
+declare const ImportEndpointConfig_base: Context.TagClass<ImportEndpointConfig, "ImportEndpointConfig", {
+    readonly endpoint: string;
+}>;
+export declare class ImportEndpointConfig extends ImportEndpointConfig_base {
+    static makeLayer: (endpoint: string) => Layer.Layer<ImportEndpointConfig, never, never>;
+    static makeProvide: (endpoint: string) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, ImportEndpointConfig>>;
+}
+declare const ImportPostsEndpointConfig_base: Context.TagClass<ImportPostsEndpointConfig, "ImportPostsEndpointConfig", {
+    readonly endpoint: string;
+    readonly useBlogPkg: boolean;
+}>;
+export declare class ImportPostsEndpointConfig extends ImportPostsEndpointConfig_base {
+    static makeLayer: (endpoint: string, useBlogPkg?: boolean) => Layer.Layer<ImportPostsEndpointConfig, never, never>;
+    static makeProvide: (endpoint: string, useBlogPkg?: boolean) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, ImportPostsEndpointConfig>>;
+}
+declare const AstroAPIContextProvider_base: Context.TagClass<AstroAPIContextProvider, "AstroAPIContextProvider", {
+    context: APIContext;
+}>;
+export declare class AstroAPIContextProvider extends AstroAPIContextProvider_base {
+    static makeLayer: (context: APIContext) => Layer.Layer<AstroAPIContextProvider, never, never>;
+    static makeProvide: (context: APIContext) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, AstroAPIContextProvider>>;
+}
+declare const RawPageData_base: Context.TagClass<RawPageData, "RawPageData", {
+    readonly page: unknown;
+}>;
+export declare class RawPageData extends RawPageData_base {
+    static makeLayer: (page: unknown) => Layer.Layer<RawPageData, never, never>;
+    static makeProvide: (page: unknown) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, RawPageData>>;
+}
+declare const FullPageData_base: Context.TagClass<FullPageData, "FullPageData", {
+    readonly pageData: PageData;
+}>;
+export declare class FullPageData extends FullPageData_base {
+    static makeLayer: (pageData: PageData) => Layer.Layer<FullPageData, never, never>;
+    static makeProvide: (pageData: PageData) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, FullPageData>>;
+}
+declare const UseBlogPkgConfig_base: Context.TagClass<UseBlogPkgConfig, "UseBlogPkgConfig", {
+    readonly useBlogPkg: boolean;
+}>;
+export declare class UseBlogPkgConfig extends UseBlogPkgConfig_base {
+    static makeLayer: (useBlogPkg: boolean) => Layer.Layer<UseBlogPkgConfig, never, never>;
+    static makeProvide: (useBlogPkg: boolean) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, UseBlogPkgConfig>>;
+}
+declare const CategoryOrTagConfig_base: Context.TagClass<CategoryOrTagConfig, "CategoryOrTagConfig", {
+    readonly value: readonly number[];
+}>;
+export declare class CategoryOrTagConfig extends CategoryOrTagConfig_base {
+    static makeLayer: (value: readonly number[]) => Layer.Layer<CategoryOrTagConfig, never, never>;
+    static makeProvide: (value: readonly number[]) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, CategoryOrTagConfig>>;
+}
+export {};

package/dist/effects/WordPressAPI/configs.js

@@ -0,0 +1,88 @@
+import { Context, Effect, Layer } from "studiocms/effect";
+class StringConfig extends Context.Tag("StringConfig")() {
+  static makeLayer = (str) => Layer.succeed(
+    this,
+    this.of({
+      str
+    })
+  );
+  static makeProvide = (str) => Effect.provide(this.makeLayer(str));
+}
+const SUPPORTED_TYPES = ["posts", "pages", "media", "categories", "tags", "settings"];
+class APIEndpointConfig extends Context.Tag("APIEndpointConfig")() {
+  static makeLayer = (endpoint, type, path) => {
+    if (!SUPPORTED_TYPES.includes(type)) {
+      throw new Error(`Invalid API type: ${type}. Supported types: ${SUPPORTED_TYPES.join(", ")}`);
+    }
+    return Layer.succeed(
+      this,
+      this.of({
+        endpoint,
+        type,
+        path
+      })
+    );
+  };
+  static makeProvide = (endpoint, type, path) => Effect.provide(this.makeLayer(endpoint, type, path));
+}
+class DownloadImageConfig extends Context.Tag("DownloadImageConfig")() {
+  static makeLayer = (imageUrl, destination) => Layer.succeed(
+    this,
+    this.of({
+      imageUrl,
+      destination
+    })
+  );
+  static makeProvide = (imageUrl, destination) => Effect.provide(this.makeLayer(imageUrl, destination));
+}
+class DownloadPostImageConfig extends Context.Tag("DownloadPostImageConfig")() {
+  static makeLayer = (str, pathToFolder) => Layer.succeed(
+    this,
+    this.of({
+      str,
+      pathToFolder
+    })
+  );
+  static makeProvide = (str, pathToFolder) => Effect.provide(this.makeLayer(str, pathToFolder));
+}
+class ImportEndpointConfig extends Context.Tag("ImportEndpointConfig")() {
+  static makeLayer = (endpoint) => Layer.succeed(this, this.of({ endpoint }));
+  static makeProvide = (endpoint) => Effect.provide(this.makeLayer(endpoint));
+}
+class ImportPostsEndpointConfig extends Context.Tag("ImportPostsEndpointConfig")() {
+  static makeLayer = (endpoint, useBlogPkg = false) => Layer.succeed(this, this.of({ endpoint, useBlogPkg }));
+  static makeProvide = (endpoint, useBlogPkg = false) => Effect.provide(this.makeLayer(endpoint, useBlogPkg));
+}
+class AstroAPIContextProvider extends Context.Tag("AstroAPIContextProvider")() {
+  static makeLayer = (context) => Layer.succeed(this, this.of({ context }));
+  static makeProvide = (context) => Effect.provide(this.makeLayer(context));
+}
+class RawPageData extends Context.Tag("RawPageData")() {
+  static makeLayer = (page) => Layer.succeed(this, this.of({ page }));
+  static makeProvide = (page) => Effect.provide(this.makeLayer(page));
+}
+class FullPageData extends Context.Tag("FullPageData")() {
+  static makeLayer = (pageData) => Layer.succeed(this, this.of({ pageData }));
+  static makeProvide = (pageData) => Effect.provide(this.makeLayer(pageData));
+}
+class UseBlogPkgConfig extends Context.Tag("UseBlogPkgConfig")() {
+  static makeLayer = (useBlogPkg) => Layer.succeed(this, this.of({ useBlogPkg }));
+  static makeProvide = (useBlogPkg) => Effect.provide(this.makeLayer(useBlogPkg));
+}
+class CategoryOrTagConfig extends Context.Tag("CategoryOrTagConfig")() {
+  static makeLayer = (value) => Layer.succeed(this, this.of({ value }));
+  static makeProvide = (value) => Effect.provide(this.makeLayer(value));
+}
+export {
+  APIEndpointConfig,
+  AstroAPIContextProvider,
+  CategoryOrTagConfig,
+  DownloadImageConfig,
+  DownloadPostImageConfig,
+  FullPageData,
+  ImportEndpointConfig,
+  ImportPostsEndpointConfig,
+  RawPageData,
+  StringConfig,
+  UseBlogPkgConfig
+};

package/dist/effects/WordPressAPI/converters.d.ts

@@ -0,0 +1,57 @@
+import { Effect } from 'studiocms/effect';
+import type { CombinedInsertContent } from 'studiocms/sdk/types';
+import { FullPageData, ImportEndpointConfig, RawPageData, UseBlogPkgConfig } from './configs.js';
+import { WPAPIError } from './errors.js';
+import { WordPressAPIUtils } from './utils.js';
+declare const WordPressAPIConverters_base: Effect.Service.Class<WordPressAPIConverters, "WordPressAPIConverters", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<WordPressAPIUtils, never, never>];
+    readonly effect: Effect.Effect<{
+        convertToPageData: Effect.Effect<{
+            readonly title: string;
+            readonly draft: boolean;
+            readonly id: string;
+            readonly slug: string;
+            readonly categories: string;
+            readonly tags: string;
+            readonly description: string;
+            readonly package: string;
+            readonly showOnNav: boolean;
+            readonly publishedAt: string;
+            readonly updatedAt: string;
+            readonly contentLang: string;
+            readonly heroImage?: string | null | undefined;
+            readonly authorId: string;
+            readonly contributorIds: string;
+            readonly showAuthor: boolean;
+            readonly showContributors: boolean;
+            readonly parentFolder?: string | null | undefined;
+            readonly augments: string;
+        }, boolean | WPAPIError | import("effect/ConfigError").ConfigError | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError, ImportEndpointConfig | RawPageData>;
+        convertToPageContent: Effect.Effect<CombinedInsertContent, boolean | WPAPIError | import("effect/ConfigError").ConfigError | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError, RawPageData | FullPageData>;
+        convertToPostData: Effect.Effect<{
+            readonly title: string;
+            readonly draft: boolean;
+            readonly id: string;
+            readonly slug: string;
+            readonly categories: string;
+            readonly tags: string;
+            readonly description: string;
+            readonly package: string;
+            readonly showOnNav: boolean;
+            readonly publishedAt: string;
+            readonly updatedAt: string;
+            readonly contentLang: string;
+            readonly heroImage?: string | null | undefined;
+            readonly authorId: string;
+            readonly contributorIds: string;
+            readonly showAuthor: boolean;
+            readonly showContributors: boolean;
+            readonly parentFolder?: string | null | undefined;
+            readonly augments: string;
+        }, boolean | import("effect/ConfigError").ConfigError | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError | import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, ImportEndpointConfig | RawPageData | UseBlogPkgConfig>;
+        convertToPostContent: Effect.Effect<CombinedInsertContent, boolean | WPAPIError | import("effect/ConfigError").ConfigError | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError, RawPageData | FullPageData>;
+    }, import("effect/ConfigError").ConfigError | import("studiocms/sdk/base").DBClientInitializationError | import("studiocms/sdk/base").SDKInitializationError, WordPressAPIUtils>;
+}>;
+export declare class WordPressAPIConverters extends WordPressAPIConverters_base {
+}
+export {};

package/dist/effects/WordPressAPI/converters.js

@@ -0,0 +1,331 @@
+import path from "node:path";
+import { SDKCore } from "studiocms:sdk";
+import { userProjectRoot } from "virtual:studiocms-devapps/config";
+import { StudioCMSPageDataCategories, StudioCMSPageDataTags } from "@withstudiocms/sdk/tables";
+import { Console, Effect, genLogger, Schema } from "studiocms/effect";
+import { decode } from "studiocms/runtime";
+import {
+  APIEndpointConfig,
+  CategoryOrTagConfig,
+  DownloadPostImageConfig,
+  FullPageData,
+  ImportEndpointConfig,
+  RawPageData,
+  StringConfig,
+  UseBlogPkgConfig
+} from "./configs.js";
+import { WPAPIError } from "./errors.js";
+import { Page, Post } from "./schema.js";
+import { WordPressAPIUtils } from "./utils.js";
+const ASTRO_PUBLIC_FOLDER = path.resolve(userProjectRoot, "public");
+const WPImportFolder = path.resolve(ASTRO_PUBLIC_FOLDER, "wp-import");
+const pagesImagesFolder = path.resolve(WPImportFolder, "pages");
+const postsImagesFolder = path.resolve(WPImportFolder, "posts");
+const sharedMeta = (data) => ({
+  augments: "[]",
+  authorId: "",
+  categories: "[]",
+  tags: "[]",
+  contributorIds: "[]",
+  draft: data.status !== "publish",
+  heroImage: void 0,
+  parentFolder: void 0,
+  showAuthor: false,
+  showContributors: false
+});
+class WordPressAPIConverters extends Effect.Service()(
+  "WordPressAPIConverters",
+  {
+    dependencies: [WordPressAPIUtils.Default],
+    effect: genLogger("@studiocms/devapps/effects/WordPressAPI/converters.effect")(function* () {
+      const sdk = yield* SDKCore;
+      const {
+        apiEndpoint,
+        cleanUpHtml,
+        downloadAndUpdateImages,
+        downloadPostImage,
+        stripHtml,
+        turndown
+      } = yield* WordPressAPIUtils;
+      const _getCategoryById = sdk.dbService.withCodec({
+        decoder: Schema.UndefinedOr(StudioCMSPageDataCategories.Select),
+        encoder: Schema.Number,
+        callbackFn: (client, id) => client(
+          (db) => db.selectFrom("StudioCMSPageDataCategories").selectAll().where("id", "=", id).executeTakeFirst()
+        )
+      });
+      const _insertCategory = sdk.dbService.withEncoder({
+        encoder: Schema.Union(
+          Schema.Array(StudioCMSPageDataCategories.Insert),
+          StudioCMSPageDataCategories.Insert
+        ),
+        callbackFn: (client, data) => client((db) => db.insertInto("StudioCMSPageDataCategories").values(data).execute())
+      });
+      const _getTagById = sdk.dbService.withCodec({
+        decoder: Schema.UndefinedOr(StudioCMSPageDataTags.Select),
+        encoder: Schema.Number,
+        callbackFn: (client, id) => client(
+          (db) => db.selectFrom("StudioCMSPageDataTags").selectAll().where("id", "=", id).executeTakeFirst()
+        )
+      });
+      const _insertTag = sdk.dbService.withEncoder({
+        encoder: Schema.Union(
+          Schema.Array(StudioCMSPageDataTags.Insert),
+          StudioCMSPageDataTags.Insert
+        ),
+        callbackFn: (client, data) => client((db) => db.insertInto("StudioCMSPageDataTags").values(data).execute())
+      });
+      const convertToPageData = genLogger(
+        "@studiocms/devapps/effects/WordPressAPI/converters.effect.convertToPageData"
+      )(function* () {
+        const [{ endpoint }, { page }] = yield* Effect.all([ImportEndpointConfig, RawPageData]);
+        if (!endpoint) {
+          return yield* new WPAPIError({ message: "Missing endpoint configuration" });
+        }
+        if (!page) {
+          return yield* new WPAPIError({ message: "Missing page data" });
+        }
+        const data = yield* Schema.decodeUnknown(Page)(page);
+        const cleanHTML = yield* stripHtml.pipe(StringConfig.makeProvide(data.excerpt.rendered));
+        const titleImageId = data.featured_media;
+        if (!titleImageId || titleImageId === 0) {
+          yield* Console.log("No featured media for:", data.title.rendered);
+          const pageData2 = {
+            ...sharedMeta(data),
+            id: crypto.randomUUID(),
+            title: data.title.rendered,
+            description: decode(cleanHTML),
+            slug: data.slug,
+            publishedAt: new Date(data.date_gmt).toISOString(),
+            updatedAt: new Date(data.modified_gmt).toISOString(),
+            showOnNav: false,
+            contentLang: "default",
+            package: "studiocms"
+          };
+          return pageData2;
+        }
+        const titleImageURL = yield* apiEndpoint.pipe(
+          APIEndpointConfig.makeProvide(endpoint, "media", String(titleImageId))
+        );
+        const titleImageResponse = yield* Effect.tryPromise(() => fetch(titleImageURL));
+        const titleImageJson = yield* Effect.tryPromise(() => titleImageResponse.json());
+        const titleImage = yield* downloadPostImage.pipe(
+          DownloadPostImageConfig.makeProvide(titleImageJson.source_url, pagesImagesFolder)
+        );
+        const pageData = {
+          ...sharedMeta(data),
+          id: crypto.randomUUID(),
+          title: data.title.rendered,
+          description: decode(cleanHTML),
+          slug: data.slug,
+          publishedAt: new Date(data.date_gmt).toISOString(),
+          updatedAt: new Date(data.modified_gmt).toISOString(),
+          showOnNav: false,
+          contentLang: "default",
+          package: "studiocms",
+          heroImage: titleImage
+        };
+        return pageData;
+      });
+      const convertToPageContent = genLogger(
+        "@studiocms/devapps/effects/WordPressAPI/converters.effect.convertToPageContent"
+      )(function* () {
+        const [
+          { page },
+          {
+            pageData: { id: pageId }
+          }
+        ] = yield* Effect.all([RawPageData, FullPageData]);
+        const data = yield* Schema.decodeUnknown(Page)(page);
+        if (!pageId) {
+          return yield* new WPAPIError({ message: "pageData is missing id" });
+        }
+        const cleanUpContent = yield* cleanUpHtml.pipe(
+          StringConfig.makeProvide(data.content.rendered)
+        );
+        const htmlWithImages = yield* downloadAndUpdateImages.pipe(
+          DownloadPostImageConfig.makeProvide(cleanUpContent, pagesImagesFolder)
+        );
+        const content = yield* turndown.pipe(StringConfig.makeProvide(htmlWithImages));
+        const pageContent = {
+          contentLang: "default",
+          content
+        };
+        return pageContent;
+      });
+      const generateCategoriesOrTags = (type) => genLogger(
+        "@studiocms/devapps/effects/WordPressAPI/converters.effect.generateCategoriesOrTags"
+      )(function* () {
+        const [{ endpoint }, { value }] = yield* Effect.all([
+          ImportEndpointConfig,
+          CategoryOrTagConfig
+        ]);
+        const TableFnMap = {
+          categories: _getCategoryById,
+          tags: _getTagById
+        };
+        const tableFn = TableFnMap[type];
+        const newItems = [];
+        const idChecks = yield* Effect.all(
+          value.map(
+            (val) => tableFn(val).pipe(Effect.map((exists) => ({ val, exists: !!exists })))
+          ),
+          { concurrency: 10 }
+        );
+        const missingIds = idChecks.filter(({ exists }) => !exists).map(({ val }) => val);
+        const fetchedIds = yield* Effect.all(
+          missingIds.map(
+            (id) => apiEndpoint.pipe(
+              APIEndpointConfig.makeProvide(endpoint, type, String(id)),
+              Effect.flatMap((url) => Effect.tryPromise(() => fetch(url))),
+              Effect.flatMap((response) => Effect.tryPromise(() => response.json()))
+            )
+          ),
+          { concurrency: 5 }
+          // Limit concurrent API calls
+        );
+        newItems.push(...fetchedIds);
+        if (newItems.length > 0) {
+          switch (type) {
+            case "categories": {
+              const data = newItems.map(
+                (category) => ({
+                  id: category.id,
+                  name: category.name,
+                  slug: category.slug,
+                  description: category.description,
+                  meta: JSON.stringify(category.meta),
+                  parent: category.parent || null
+                })
+              );
+              yield* Console.log(
+                "Inserting new Categories into the database:",
+                data.map((d) => `${d.id}: ${d.name}`).join(", ")
+              );
+              yield* _insertCategory(data);
+              yield* Console.log("Categories inserted!");
+              break;
+            }
+            case "tags": {
+              const tagData = newItems.map(
+                (tag) => ({
+                  id: tag.id,
+                  name: tag.name,
+                  slug: tag.slug,
+                  description: tag.description,
+                  meta: JSON.stringify(tag.meta)
+                })
+              );
+              yield* Console.log(
+                "Inserting new Tags into the database:",
+                tagData.map((data) => `${data.id}: ${data.name}`).join(", ")
+              );
+              yield* _insertTag(tagData);
+              yield* Console.log("Tags inserted!");
+              break;
+            }
+          }
+        }
+      });
+      const convertToPostData = genLogger(
+        "@studiocms/devapps/effects/WordPressAPI/converters.effect.convertToPostData"
+      )(function* () {
+        const [{ endpoint }, { page: post }, { useBlogPkg }] = yield* Effect.all([
+          ImportEndpointConfig,
+          RawPageData,
+          UseBlogPkgConfig
+        ]);
+        const data = yield* Schema.decodeUnknown(Post)(post);
+        const pkg = useBlogPkg ? "@studiocms/blog" : "studiocms/markdown";
+        const cleanedHTML = yield* stripHtml.pipe(StringConfig.makeProvide(data.excerpt.rendered));
+        const titleImageId = data.featured_media;
+        if (!titleImageId || titleImageId === 0) {
+          yield* Console.log("No featured media for:", data.title.rendered);
+          const pageData2 = {
+            ...sharedMeta(data),
+            id: crypto.randomUUID(),
+            title: data.title.rendered,
+            description: decode(cleanedHTML),
+            slug: data.slug,
+            publishedAt: new Date(data.date_gmt).toISOString(),
+            updatedAt: new Date(data.modified_gmt).toISOString(),
+            showOnNav: false,
+            contentLang: "default",
+            package: pkg,
+            categories: JSON.stringify(data.categories),
+            tags: JSON.stringify(data.tags)
+          };
+          return pageData2;
+        }
+        const titleImageURL = yield* apiEndpoint.pipe(
+          APIEndpointConfig.makeProvide(endpoint, "media", String(titleImageId))
+        );
+        const titleImageResponse = yield* Effect.tryPromise(() => fetch(titleImageURL));
+        const titleImageJson = yield* Effect.tryPromise(() => titleImageResponse.json());
+        const titleImage = yield* downloadPostImage.pipe(
+          DownloadPostImageConfig.makeProvide(titleImageJson.source_url, postsImagesFolder)
+        );
+        yield* generateCategoriesOrTags("categories").pipe(
+          ImportEndpointConfig.makeProvide(endpoint),
+          CategoryOrTagConfig.makeProvide(data.categories)
+        );
+        yield* generateCategoriesOrTags("tags").pipe(
+          ImportEndpointConfig.makeProvide(endpoint),
+          CategoryOrTagConfig.makeProvide(data.tags)
+        );
+        const pageData = {
+          ...sharedMeta(data),
+          id: crypto.randomUUID(),
+          title: data.title.rendered,
+          description: decode(cleanedHTML),
+          slug: data.slug,
+          publishedAt: new Date(data.date_gmt).toISOString(),
+          updatedAt: new Date(data.modified_gmt).toISOString(),
+          showOnNav: false,
+          contentLang: "default",
+          package: pkg,
+          categories: JSON.stringify(data.categories),
+          tags: JSON.stringify(data.tags),
+          heroImage: titleImage
+        };
+        return pageData;
+      });
+      const convertToPostContent = genLogger(
+        "@studiocms/devapps/effects/WordPressAPI/converters.effect.convertToPostContent"
+      )(function* () {
+        const [
+          {
+            pageData: { id: pageId }
+          },
+          { page: post }
+        ] = yield* Effect.all([FullPageData, RawPageData]);
+        const data = yield* Schema.decodeUnknown(Post)(post);
+        if (!pageId) {
+          return yield* new WPAPIError({ message: "pageData is missing id" });
+        }
+        const cleanupContent = yield* cleanUpHtml.pipe(
+          StringConfig.makeProvide(data.content.rendered)
+        );
+        const htmlWithImages = yield* downloadAndUpdateImages.pipe(
+          DownloadPostImageConfig.makeProvide(cleanupContent, postsImagesFolder)
+        );
+        const content = yield* turndown.pipe(StringConfig.makeProvide(htmlWithImages));
+        const pageContent = {
+          contentLang: "default",
+          content
+        };
+        return pageContent;
+      });
+      return {
+        convertToPageData,
+        convertToPageContent,
+        convertToPostData,
+        convertToPostContent
+      };
+    })
+  }
+) {
+}
+export {
+  WordPressAPIConverters
+};

package/dist/effects/WordPressAPI/errors.d.ts

@@ -0,0 +1,12 @@
+declare const WPAPIError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "WPAPIError";
+} & Readonly<A>;
+/**
+ * Error class for WordPress API related errors.
+ */
+export declare class WPAPIError extends WPAPIError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+export {};

package/dist/effects/WordPressAPI/errors.js

@@ -0,0 +1,6 @@
+import { Data } from "effect";
+class WPAPIError extends Data.TaggedError("WPAPIError") {
+}
+export {
+  WPAPIError
+};

package/dist/effects/WordPressAPI/importers.d.ts

@@ -0,0 +1,19 @@
+import type { StudioCMSPageContent, StudioCMSPageData } from '@withstudiocms/sdk/tables';
+import { Effect } from 'studiocms/effect';
+import { ImportEndpointConfig, ImportPostsEndpointConfig } from './configs.js';
+import { WordPressAPIConverters } from './converters.js';
+import { WordPressAPIUtils } from './utils.js';
+export type PageData = (typeof StudioCMSPageData)['Insert']['Type'];
+export type PageContent = (typeof StudioCMSPageContent)['Insert']['Type'];
+declare const WordPressAPI_base: Effect.Service.Class<WordPressAPI, "WordPressAPI", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<WordPressAPIUtils, never, never>, import("effect/Layer").Layer<WordPressAPIConverters, import("effect/ConfigError").ConfigError | import("studiocms/sdk/base").DBClientInitializationError | import("studiocms/sdk/base").SDKInitializationError, never>];
+    readonly effect: Effect.Effect<{
+        importSettingsFromWPAPI: Effect.Effect<void, boolean | import("effect/ConfigError").ConfigError | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError | import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, ImportEndpointConfig>;
+        importPagesFromWPAPI: Effect.Effect<void, boolean | import("./errors.js").WPAPIError | import("effect/ConfigError").ConfigError | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError | import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, ImportEndpointConfig>;
+        importPostsFromWPAPI: Effect.Effect<void, boolean | import("./errors.js").WPAPIError | import("effect/ConfigError").ConfigError | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError | import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, ImportPostsEndpointConfig>;
+    }, import("effect/ConfigError").ConfigError | import("studiocms/sdk/base").DBClientInitializationError | import("studiocms/sdk/base").SDKInitializationError, WordPressAPIUtils | WordPressAPIConverters>;
+}>;
+export declare class WordPressAPI extends WordPressAPI_base {
+    static Provide: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, import("effect/ConfigError").ConfigError | import("studiocms/sdk/base").DBClientInitializationError | import("studiocms/sdk/base").SDKInitializationError | E, Exclude<R, WordPressAPI>>;
+}
+export {};