@studiocms/devapps 0.1.0-beta.17 → 0.1.0-beta.19

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,27 @@
+import { Effect } from 'studiocms/effect';
+import { FullPageData, ImportEndpointConfig, RawPageData, UseBlogPkgConfig } from './configs.js';
+import { WordPressAPIUtils } from './utils.js';
+declare const WordPressAPIConverters_base: Effect.Service.Class<WordPressAPIConverters, "WordPressAPIConverters", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<import("studiocms/sdk/sdkCore").SDKCore, never, never>, import("effect/Layer").Layer<WordPressAPIUtils, never, never>];
+    readonly effect: Effect.Effect<{
+        convertToPageData: Effect.Effect<{
+            title: string;
+            slug: string;
+            description: string;
+        }, boolean | Error | import("effect/ParseResult").ParseError, ImportEndpointConfig | RawPageData>;
+        convertToPageContent: Effect.Effect<{
+            contentId: string;
+        }, boolean | Error | import("effect/ParseResult").ParseError, RawPageData | FullPageData>;
+        convertToPostData: Effect.Effect<{
+            title: string;
+            slug: string;
+            description: string;
+        }, boolean | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("studiocms/sdk/effect/db").LibSQLDatabaseError | import("effect/ParseResult").ParseError, ImportEndpointConfig | RawPageData | UseBlogPkgConfig>;
+        convertToPostContent: Effect.Effect<{
+            contentId: string;
+        }, boolean | Error | import("effect/ParseResult").ParseError, RawPageData | FullPageData>;
+    }, never, WordPressAPIUtils | import("studiocms/sdk/sdkCore").SDKCore>;
+}>;
+export declare class WordPressAPIConverters extends WordPressAPIConverters_base {
+}
+export {};

package/dist/effects/WordPressAPI/converters.js

@@ -0,0 +1,299 @@
+import path from "node:path";
+import { eq } from "astro:db";
+import { SDKCore } from "studiocms:sdk";
+import { userProjectRoot } from "virtual:studiocms-devapps/config";
+import { Console, Effect, Schema, genLogger } from "studiocms/effect";
+import { decode } from "studiocms/runtime";
+import { tsPageDataCategories, tsPageDataTags } from "studiocms/sdk/tables";
+import {
+  APIEndpointConfig,
+  CategoryOrTagConfig,
+  DownloadPostImageConfig,
+  FullPageData,
+  ImportEndpointConfig,
+  RawPageData,
+  StringConfig,
+  UseBlogPkgConfig
+} from "./configs.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");
+class WordPressAPIConverters extends Effect.Service()(
+  "WordPressAPIConverters",
+  {
+    dependencies: [SDKCore.Default, 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 convertToPageData = genLogger(
+        "@studiocms/devapps/effects/WordPressAPI/converters.effect.convertToPageData"
+      )(function* () {
+        const [{ endpoint }, { page }] = yield* Effect.all([ImportEndpointConfig, RawPageData]);
+        if (!endpoint) {
+          yield* Effect.fail(new Error("Missing endpoint configuration"));
+        }
+        if (!page) {
+          yield* Effect.fail(new Error("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 = {
+            // @ts-expect-error - Drizzle broke this
+            id: crypto.randomUUID(),
+            title: data.title.rendered,
+            description: decode(cleanHTML),
+            slug: data.slug,
+            publishedAt: new Date(data.date_gmt),
+            updatedAt: new Date(data.modified_gmt),
+            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 = {
+          // @ts-expect-error - Drizzle broke this
+          id: crypto.randomUUID(),
+          title: data.title.rendered,
+          description: decode(cleanHTML),
+          slug: data.slug,
+          publishedAt: new Date(data.date_gmt),
+          updatedAt: new Date(data.modified_gmt),
+          showOnNav: false,
+          contentLang: "default",
+          package: "studiocms",
+          heroImage: titleImage
+        };
+        return pageData;
+      });
+      const convertToPageContent = genLogger(
+        "@studiocms/devapps/effects/WordPressAPI/converters.effect.convertToPageContent"
+      )(function* () {
+        const [{ page }, { pageData }] = yield* Effect.all([RawPageData, FullPageData]);
+        const data = yield* Schema.decodeUnknown(Page)(page);
+        if (pageData.id === void 0) {
+          yield* Effect.fail(new Error("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 = {
+          // @ts-expect-error - Drizzle broke this
+          id: crypto.randomUUID(),
+          // @ts-expect-error - Drizzle broke this
+          contentId: pageData.id,
+          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 TableMap = {
+          categories: tsPageDataCategories,
+          tags: tsPageDataTags
+        };
+        const table = TableMap[type];
+        const newItems = [];
+        const idChecks = yield* Effect.all(
+          value.map(
+            (val) => sdk.dbService.execute((client) => client.select().from(table).where(eq(table.id, val)).get()).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) => {
+                const data2 = {
+                  // @ts-expect-error - Drizzle broke this
+                  id: category.id,
+                  name: category.name,
+                  slug: category.slug,
+                  description: category.description,
+                  meta: JSON.stringify(category.meta)
+                };
+                if (category.parent) {
+                  data2.parent = category.parent;
+                }
+                return data2;
+              });
+              yield* Console.log(
+                "Inserting new Categories into the database:",
+                data.map((d) => `${d.id}: ${d.name}`).join(", ")
+              );
+              yield* sdk.dbService.execute(
+                (client) => client.insert(tsPageDataCategories).values(data)
+              );
+              yield* Console.log("Categories inserted!");
+              break;
+            }
+            case "tags": {
+              const tagData = newItems.map((tag) => {
+                const data = {
+                  // @ts-expect-error - Drizzle broke this
+                  id: tag.id,
+                  name: tag.name,
+                  slug: tag.slug,
+                  description: tag.description,
+                  meta: JSON.stringify(tag.meta)
+                };
+                return data;
+              });
+              yield* Console.log(
+                "Inserting new Tags into the database:",
+                tagData.map((data) => `${data.id}: ${data.name}`).join(", ")
+              );
+              yield* sdk.dbService.execute(
+                (client) => client.insert(tsPageDataTags).values(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 = {
+            // @ts-expect-error - Drizzle broke this
+            id: crypto.randomUUID(),
+            title: data.title.rendered,
+            description: decode(cleanedHTML),
+            slug: data.slug,
+            publishedAt: new Date(data.date_gmt),
+            updatedAt: new Date(data.modified_gmt),
+            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 = {
+          // @ts-expect-error - Drizzle broke this
+          id: crypto.randomUUID(),
+          title: data.title.rendered,
+          description: decode(cleanedHTML),
+          slug: data.slug,
+          publishedAt: new Date(data.date_gmt),
+          updatedAt: new Date(data.modified_gmt),
+          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 }, { page: post }] = yield* Effect.all([FullPageData, RawPageData]);
+        const data = yield* Schema.decodeUnknown(Post)(post);
+        if (pageData.id === void 0) {
+          yield* Effect.fail(new Error("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 = {
+          // @ts-expect-error - Drizzle broke this
+          id: crypto.randomUUID(),
+          // @ts-expect-error - Drizzle broke this
+          contentId: pageData.id,
+          contentLang: "default",
+          content
+        };
+        return pageContent;
+      });
+      return {
+        convertToPageData,
+        convertToPageContent,
+        convertToPostData,
+        convertToPostContent
+      };
+    })
+  }
+) {
+}
+export {
+  WordPressAPIConverters
+};

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

@@ -0,0 +1,19 @@
+import { Effect } from 'studiocms/effect';
+import type { tsPageContent, tsPageData } from 'studiocms/sdk/tables';
+import { ImportEndpointConfig, ImportPostsEndpointConfig } from './configs.js';
+import { WordPressAPIConverters } from './converters.js';
+import { WordPressAPIUtils } from './utils.js';
+export type PageData = typeof tsPageData.$inferInsert;
+export type PageContent = typeof tsPageContent.$inferInsert;
+declare const WordPressAPI_base: Effect.Service.Class<WordPressAPI, "WordPressAPI", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<import("studiocms/sdk/sdkCore").SDKCore, never, never>, import("effect/Layer").Layer<WordPressAPIUtils, never, never>, import("effect/Layer").Layer<WordPressAPIConverters, never, never>];
+    readonly effect: Effect.Effect<{
+        importSettingsFromWPAPI: Effect.Effect<void, boolean | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("studiocms/sdk/errors").SDKCoreError | import("effect/ParseResult").ParseError, ImportEndpointConfig>;
+        importPagesFromWPAPI: Effect.Effect<void, boolean | Error | import("studiocms/sdk/errors").SDKCoreError | import("effect/ParseResult").ParseError, ImportEndpointConfig>;
+        importPostsFromWPAPI: Effect.Effect<void, boolean | Error | import("studiocms/sdk/effect/db").LibSQLDatabaseError | import("studiocms/sdk/errors").SDKCoreError | import("effect/ParseResult").ParseError, ImportPostsEndpointConfig>;
+    }, never, WordPressAPIUtils | WordPressAPIConverters | import("studiocms/sdk/sdkCore").SDKCore>;
+}>;
+export declare class WordPressAPI extends WordPressAPI_base {
+    static Provide: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, WordPressAPI>>;
+}
+export {};

package/dist/effects/WordPressAPI/importers.js

@@ -0,0 +1,122 @@
+import path from "node:path";
+import { SDKCore } from "studiocms:sdk";
+import { userProjectRoot } from "virtual:studiocms-devapps/config";
+import { Console, Effect, Schema, genLogger } from "studiocms/effect";
+import {
+  APIEndpointConfig,
+  DownloadPostImageConfig,
+  FullPageData,
+  ImportEndpointConfig,
+  ImportPostsEndpointConfig,
+  RawPageData,
+  UseBlogPkgConfig
+} from "./configs.js";
+import { WordPressAPIConverters } from "./converters.js";
+import { PagesSchema, PostsSchema, SiteSettings } from "./schema.js";
+import { WordPressAPIUtils } from "./utils.js";
+const ASTRO_PUBLIC_FOLDER = path.resolve(userProjectRoot, "public");
+class WordPressAPI extends Effect.Service()("WordPressAPI", {
+  dependencies: [SDKCore.Default, WordPressAPIUtils.Default, WordPressAPIConverters.Default],
+  effect: genLogger("@studiocms/devapps/effects/WordPressAPI.effect")(function* () {
+    const sdk = yield* SDKCore;
+    const { apiEndpoint, downloadPostImage, fetchAll } = yield* WordPressAPIUtils;
+    const { convertToPageContent, convertToPageData, convertToPostContent, convertToPostData } = yield* WordPressAPIConverters;
+    const importSettingsFromWPAPI = genLogger(
+      "@studiocms/devapps/effects/WordPressAPI.effect.importSettingsFromWPAPI"
+    )(function* () {
+      const { endpoint } = yield* ImportEndpointConfig;
+      const url = yield* apiEndpoint.pipe(APIEndpointConfig.makeProvide(endpoint, "settings"));
+      yield* Console.log("Fetching site settings from: ", url.origin);
+      const response = yield* Effect.tryPromise(() => fetch(url));
+      const rawSettings = yield* Effect.tryPromise(() => response.json());
+      const settings = yield* Schema.decodeUnknown(SiteSettings)(rawSettings);
+      yield* Console.log("Importing site settings: ", settings);
+      let siteIcon = void 0;
+      if (settings.site_icon_url) {
+        siteIcon = yield* downloadPostImage.pipe(
+          DownloadPostImageConfig.makeProvide(settings.site_icon_url, ASTRO_PUBLIC_FOLDER)
+        );
+      }
+      if (!settings.site_icon_url && settings.site_logo) {
+        const siteLogoUrl = yield* apiEndpoint.pipe(
+          APIEndpointConfig.makeProvide(endpoint, "media", String(settings.site_logo))
+        );
+        const siteLogoResponse = yield* Effect.tryPromise(() => fetch(siteLogoUrl));
+        const siteLogoData = yield* Effect.tryPromise(() => siteLogoResponse.json());
+        siteIcon = yield* downloadPostImage.pipe(
+          DownloadPostImageConfig.makeProvide(siteLogoData.source_url, ASTRO_PUBLIC_FOLDER)
+        );
+      }
+      const siteConfig = {
+        title: settings.name,
+        description: settings.description
+      };
+      if (siteIcon) {
+        siteConfig.siteIcon = siteIcon;
+      }
+      const insert = yield* sdk.UPDATE.siteConfig(siteConfig);
+      if (insert.lastCacheUpdate) {
+        yield* Console.log("Updated site settings");
+      } else {
+        yield* Console.error("Failed to update site settings");
+      }
+    });
+    const importPagesFromWPAPI = genLogger(
+      "@studiocms/devapps/effects/WordPressAPI.effect.importPagesFromWPAPI"
+    )(function* () {
+      const { endpoint } = yield* ImportEndpointConfig;
+      const url = yield* apiEndpoint.pipe(APIEndpointConfig.makeProvide(endpoint, "pages"));
+      yield* Console.log("fetching pages from: ", url.origin);
+      const rawPages = yield* fetchAll(url);
+      const { pages } = yield* Schema.decodeUnknown(PagesSchema)({ pages: rawPages });
+      yield* Console.log("Total pages: ", pages.length);
+      for (const page of pages) {
+        yield* Console.log("importing page:", page.title.rendered);
+        const pageData = yield* convertToPageData.pipe(
+          ImportEndpointConfig.makeProvide(endpoint),
+          RawPageData.makeProvide(page)
+        );
+        const pageContent = yield* convertToPageContent.pipe(
+          RawPageData.makeProvide(page),
+          FullPageData.makeProvide(pageData)
+        );
+        yield* sdk.POST.databaseEntry.pages(pageData, pageContent);
+        yield* Console.log("- Imported new page from WP-API: ", page.title.rendered);
+      }
+    });
+    const importPostsFromWPAPI = genLogger(
+      "@studiocms/devapps/effects/WordPressAPI.effect.importPostsFromWPAPI"
+    )(function* () {
+      const { endpoint, useBlogPkg } = yield* ImportPostsEndpointConfig;
+      const url = yield* apiEndpoint.pipe(APIEndpointConfig.makeProvide(endpoint, "posts"));
+      yield* Console.log("fetching posts from: ", url.origin);
+      const rawPages = yield* fetchAll(url);
+      const { posts: pages } = yield* Schema.decodeUnknown(PostsSchema)({ posts: rawPages });
+      yield* Console.log("Total posts: ", pages.length);
+      for (const page of pages) {
+        yield* Console.log("importing post:", page.title.rendered);
+        const pageData = yield* convertToPostData.pipe(
+          ImportEndpointConfig.makeProvide(endpoint),
+          RawPageData.makeProvide(page),
+          UseBlogPkgConfig.makeProvide(useBlogPkg)
+        );
+        const pageContent = yield* convertToPostContent.pipe(
+          RawPageData.makeProvide(page),
+          FullPageData.makeProvide(pageData)
+        );
+        yield* sdk.POST.databaseEntry.pages(pageData, pageContent);
+        yield* Console.log("- Imported new post from WP-API: ", page.title.rendered);
+      }
+    });
+    return {
+      importSettingsFromWPAPI,
+      importPagesFromWPAPI,
+      importPostsFromWPAPI
+    };
+  })
+}) {
+  static Provide = Effect.provide(this.Default);
+}
+export {
+  WordPressAPI
+};