@studiocms/devapps 0.1.0-beta.30 → 0.1.0-beta.31

package/README.md

@@ -52,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

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

@@ -6,50 +6,50 @@ declare const WordPressAPIConverters_base: Effect.Service.Class<WordPressAPIConv
     readonly dependencies: readonly [import("effect/Layer").Layer<WordPressAPIUtils, never, never>];
     readonly effect: Effect.Effect<{
         convertToPageData: Effect.Effect<{
-            title: string;
-            slug: string;
-            description: string;
-            draft?: boolean | null | undefined;
-            id?: string | undefined;
-            categories?: unknown;
-            tags?: unknown;
-            package?: string | undefined;
-            showOnNav?: boolean | undefined;
-            publishedAt?: Date | undefined;
-            updatedAt?: Date | null | undefined;
-            contentLang?: string | undefined;
-            heroImage?: string | undefined;
-            authorId?: string | null | undefined;
-            contributorIds?: unknown;
-            showAuthor?: boolean | null | undefined;
-            showContributors?: boolean | null | undefined;
-            parentFolder?: string | null | undefined;
-            augments?: unknown;
-        }, boolean | Error | import("effect/ParseResult").ParseError, ImportEndpointConfig | RawPageData>;
-        convertToPageContent: Effect.Effect<CombinedInsertContent, boolean | Error | import("effect/ParseResult").ParseError, RawPageData | FullPageData>;
+            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 | Error | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError, ImportEndpointConfig | RawPageData>;
+        convertToPageContent: Effect.Effect<CombinedInsertContent, boolean | Error | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError, RawPageData | FullPageData>;
         convertToPostData: Effect.Effect<{
-            title: string;
-            slug: string;
-            description: string;
-            draft?: boolean | null | undefined;
-            id?: string | undefined;
-            categories?: unknown;
-            tags?: unknown;
-            package?: string | undefined;
-            showOnNav?: boolean | undefined;
-            publishedAt?: Date | undefined;
-            updatedAt?: Date | null | undefined;
-            contentLang?: string | undefined;
-            heroImage?: string | undefined;
-            authorId?: string | null | undefined;
-            contributorIds?: unknown;
-            showAuthor?: boolean | null | undefined;
-            showContributors?: boolean | null | undefined;
-            parentFolder?: string | null | undefined;
-            augments?: unknown;
-        }, boolean | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError | import("@withstudiocms/effect/drizzle").LibSQLClientError, ImportEndpointConfig | RawPageData | UseBlogPkgConfig>;
-        convertToPostContent: Effect.Effect<CombinedInsertContent, boolean | Error | import("effect/ParseResult").ParseError, RawPageData | FullPageData>;
-    }, never, WordPressAPIUtils>;
+            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").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, ImportEndpointConfig | RawPageData | UseBlogPkgConfig>;
+        convertToPostContent: Effect.Effect<CombinedInsertContent, boolean | Error | import("effect/ConfigError").ConfigError | 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 {
 }

package/dist/effects/WordPressAPI/converters.js

@@ -1,10 +1,9 @@
-import { eq } from "astro:db";
 import path from "node:path";
 import { SDKCore } from "studiocms:sdk";
 import { userProjectRoot } from "virtual:studiocms-devapps/config";
+import { StudioCMSPageDataCategories, StudioCMSPageDataTags } from "@withstudiocms/kysely";
 import { Console, Effect, genLogger, Schema } from "studiocms/effect";
 import { decode } from "studiocms/runtime";
-import { tsPageDataCategories, tsPageDataTags } from "studiocms/sdk/tables";
 import {
   APIEndpointConfig,
   CategoryOrTagConfig,
@@ -21,6 +20,18 @@ 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",
   {
@@ -35,6 +46,34 @@ class WordPressAPIConverters extends Effect.Service()(
         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* () {
@@ -51,12 +90,13 @@ class WordPressAPIConverters extends Effect.Service()(
         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),
-            updatedAt: new Date(data.modified_gmt),
+            publishedAt: new Date(data.date_gmt).toISOString(),
+            updatedAt: new Date(data.modified_gmt).toISOString(),
             showOnNav: false,
             contentLang: "default",
             package: "studiocms"
@@ -72,12 +112,13 @@ class WordPressAPIConverters extends Effect.Service()(
           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),
-          updatedAt: new Date(data.modified_gmt),
+          publishedAt: new Date(data.date_gmt).toISOString(),
+          updatedAt: new Date(data.modified_gmt).toISOString(),
           showOnNav: false,
           contentLang: "default",
           package: "studiocms",
@@ -118,15 +159,15 @@ class WordPressAPIConverters extends Effect.Service()(
           ImportEndpointConfig,
           CategoryOrTagConfig
         ]);
-        const TableMap = {
-          categories: tsPageDataCategories,
-          tags: tsPageDataTags
+        const TableFnMap = {
+          categories: _getCategoryById,
+          tags: _getTagById
         };
-        const table = TableMap[type];
+        const tableFn = TableFnMap[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 })))
+            (val) => tableFn(val).pipe(Effect.map((exists) => ({ val, exists: !!exists })))
           ),
           { concurrency: 10 }
         );
@@ -146,47 +187,39 @@ class WordPressAPIConverters extends Effect.Service()(
         if (newItems.length > 0) {
           switch (type) {
             case "categories": {
-              const data = newItems.map((category) => {
-                const data2 = {
+              const data = newItems.map(
+                (category) => ({
                   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;
-              });
+                  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* sdk.dbService.execute(
-                (client) => client.insert(tsPageDataCategories).values(data)
-              );
+              yield* _insertCategory(data);
               yield* Console.log("Categories inserted!");
               break;
             }
             case "tags": {
-              const tagData = newItems.map((tag) => {
-                const data = {
+              const tagData = newItems.map(
+                (tag) => ({
                   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* _insertTag(tagData);
               yield* Console.log("Tags inserted!");
               break;
             }
@@ -208,12 +241,13 @@ class WordPressAPIConverters extends Effect.Service()(
         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),
-            updatedAt: new Date(data.modified_gmt),
+            publishedAt: new Date(data.date_gmt).toISOString(),
+            updatedAt: new Date(data.modified_gmt).toISOString(),
             showOnNav: false,
             contentLang: "default",
             package: pkg,
@@ -239,12 +273,13 @@ class WordPressAPIConverters extends Effect.Service()(
           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),
-          updatedAt: new Date(data.modified_gmt),
+          publishedAt: new Date(data.date_gmt).toISOString(),
+          updatedAt: new Date(data.modified_gmt).toISOString(),
           showOnNav: false,
           contentLang: "default",
           package: pkg,

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

@@ -1,19 +1,19 @@
+import type { StudioCMSPageContent, StudioCMSPageData } from '@withstudiocms/kysely';
 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;
+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, never, never>];
+    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 | Error | import("effect/ParseResult").ParseError, ImportEndpointConfig>;
-        importPagesFromWPAPI: Effect.Effect<void, boolean | Error | import("effect/ParseResult").ParseError | import("studiocms/sdk/errors").SDKCoreError, ImportEndpointConfig>;
-        importPostsFromWPAPI: Effect.Effect<void, boolean | Error | import("effect/ParseResult").ParseError | import("studiocms/sdk/errors").SDKCoreError, ImportPostsEndpointConfig>;
-    }, never, WordPressAPIUtils | WordPressAPIConverters>;
+        importSettingsFromWPAPI: Effect.Effect<void, boolean | import("effect/ConfigError").ConfigError | import("astro/errors").AstroError | import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError | import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, ImportEndpointConfig>;
+        importPagesFromWPAPI: Effect.Effect<void, boolean | Error | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError, ImportEndpointConfig>;
+        importPostsFromWPAPI: Effect.Effect<void, boolean | Error | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError, 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, E, Exclude<R, WordPressAPI>>;
+    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 {};

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

@@ -1,15 +1,15 @@
 import { AstroError } from 'astro/errors';
-import { Effect } from 'studiocms/effect';
+import { type ConfigError, Effect } from 'studiocms/effect';
 import { APIEndpointConfig, DownloadPostImageConfig, StringConfig } from './configs.js';
 declare const WordPressAPIUtils_base: Effect.Service.Class<WordPressAPIUtils, "WordPressAPIUtils", {
     readonly effect: Effect.Effect<{
-        turndown: Effect.Effect<string, AstroError, StringConfig>;
-        stripHtml: Effect.Effect<string, import("effect/Cause").UnknownException, StringConfig>;
-        cleanUpHtml: Effect.Effect<string, AstroError, StringConfig>;
-        fetchAll: (url: URL, page?: number, results?: any[]) => Effect.Effect<any[], AstroError, never>;
-        apiEndpoint: Effect.Effect<URL, AstroError, APIEndpointConfig>;
-        downloadPostImage: Effect.Effect<string | undefined, boolean | import("effect/Cause").UnknownException, DownloadPostImageConfig>;
-        downloadAndUpdateImages: Effect.Effect<string, boolean | AstroError | import("effect/Cause").UnknownException, DownloadPostImageConfig>;
+        turndown: Effect.Effect<string, ConfigError.ConfigError | AstroError, StringConfig>;
+        stripHtml: Effect.Effect<string, ConfigError.ConfigError | import("effect/Cause").UnknownException, StringConfig>;
+        cleanUpHtml: Effect.Effect<string, ConfigError.ConfigError | AstroError, StringConfig>;
+        fetchAll: (url: URL, page?: number, results?: any[]) => Effect.Effect<any[], ConfigError.ConfigError | AstroError, never>;
+        apiEndpoint: Effect.Effect<URL, ConfigError.ConfigError | AstroError, APIEndpointConfig>;
+        downloadPostImage: Effect.Effect<string | undefined, boolean | ConfigError.ConfigError | import("effect/Cause").UnknownException, DownloadPostImageConfig>;
+        downloadAndUpdateImages: Effect.Effect<string, boolean | ConfigError.ConfigError | AstroError | import("effect/Cause").UnknownException, DownloadPostImageConfig>;
     }, never, never>;
 }>;
 export declare class WordPressAPIUtils extends WordPressAPIUtils_base {

package/dist/effects/wpImporter.d.ts

@@ -2,12 +2,12 @@ import { Effect } from 'studiocms/effect';
 import { AstroAPIContextProvider } from './WordPressAPI/configs.js';
 import { WordPressAPI } from './WordPressAPI/importers.js';
 declare const WPImporter_base: Effect.Service.Class<WPImporter, "WPImporter", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<WordPressAPI, never, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<WordPressAPI, import("effect/ConfigError").ConfigError | import("studiocms/sdk/base").DBClientInitializationError | import("studiocms/sdk/base").SDKInitializationError, never>];
     readonly effect: Effect.Effect<{
-        runPostEvent: Effect.Effect<Response, boolean | Error | import("effect/ParseResult").ParseError | import("studiocms/sdk/errors").SDKCoreError, AstroAPIContextProvider>;
-    }, never, WordPressAPI>;
+        runPostEvent: Effect.Effect<Response, boolean | Error | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError, AstroAPIContextProvider>;
+    }, import("effect/ConfigError").ConfigError, WordPressAPI>;
 }>;
 export declare class WPImporter extends WPImporter_base {
-    static Provide: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, WPImporter>>;
+    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, WPImporter>>;
 }
 export {};

package/dist/index.d.ts

@@ -26,9 +26,6 @@ import { type StudioCMSDevAppsOptions } from './schema/index.js';
  *           enabled: true,
  *           endpoint: '/wp-import',
  *         },
- *         libSQLViewer: {
- *           enabled: true,
- *         },
  *       },
  *       verbose: true,
  *     }),

package/dist/index.js

@@ -1,12 +1,10 @@
 import { addVirtualImports, createResolver, injectDevRoute } from "astro-integration-kit";
-import { loadEnv } from "vite";
 import { StudioCMSDevAppsSchema } from "./schema/index.js";
 import { pathGenerator } from "./utils/pathGenerator.js";
 function studioCMSDevApps(opts) {
   const options = StudioCMSDevAppsSchema.parse(opts);
   const { resolve } = createResolver(import.meta.url);
   let makeEndpointPath;
-  const astroDbEnv = loadEnv("all", process.cwd(), "ASTRO_DB");
   return {
     name: "@studiocms/devapps",
     hooks: {
@@ -16,37 +14,17 @@ function studioCMSDevApps(opts) {
         options.verbose && logger.info("Setting up StudioCMS DevApps");
         if (command === "dev") {
           const wpAPIPath = makeEndpointPath(options.appsConfig.wpImporter.endpoint);
-          const libsqlIFrame = makeEndpointPath(options.appsConfig.libSQLViewer.endpoint);
           addVirtualImports(params, {
             name: "@studiocms/devapps",
             imports: {
               "virtual:studiocms-devapps/endpoints": `
 								export const wpAPIEndpoint = "${wpAPIPath}";
-								export const libsqlEndpoint = "${libsqlIFrame}";
 							`,
               "virtual:studiocms-devapps/config": `
 								export const userProjectRoot = "${config.root.pathname}";
-
-								export const dbEnv = {
-									remoteUrl: "${astroDbEnv.ASTRO_DB_REMOTE_URL}",
-									token: "${astroDbEnv.ASTRO_DB_APP_TOKEN}",
-								};
 							`
             }
           });
-          if (options.appsConfig.libSQLViewer.enabled) {
-            options.verbose && logger.info("Adding Dev Toolbar App: LibSQL Viewer");
-            injectDevRoute(params, {
-              entrypoint: resolve("./routes/outerbase.astro"),
-              pattern: libsqlIFrame
-            });
-            addDevToolbarApp({
-              name: "Outerbase Studio Embedded",
-              id: "studiocms-devapps-libsql-viewer",
-              entrypoint: resolve("./apps/libsql-viewer.js"),
-              icon: '<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg" class="mb-4 hidden size-4 md:block"><path fill-rule="evenodd" clip-rule="evenodd" d="M20 0C8.97048 0 0 8.96666 0 19.9999C0 31.0227 8.97048 40 20 40C31.0294 40 40 31.0333 40 19.9999C40 8.96666 31.0294 0 20 0ZM27.4346 33.7676L27.3343 33.8966C26.2881 35.1776 25.0082 35.5974 24.1178 35.7158C23.8841 35.748 23.6504 35.759 23.4056 35.759C20.9794 35.759 18.5308 34.112 16.3272 30.9795C14.5353 28.4284 12.9771 25.027 11.9421 21.3992C10.1057 14.9299 10.3172 9.03117 12.4763 6.36169C13.5225 5.08067 14.8024 4.66086 15.6928 4.5425C18.2192 4.19787 20.8013 5.67267 23.1385 8.79421C25.0749 11.3779 26.7445 14.9408 27.8576 18.8481C29.6716 25.2207 29.4935 31.0549 27.4346 33.7676Z" fill="currentColor"></path></svg>'
-            });
-          }
           if (options.appsConfig.wpImporter.enabled) {
             options.verbose && logger.info("Adding Dev Toolbar App: WP API Importer");
             injectDevRoute(params, {

package/dist/schema/index.d.ts

@@ -23,16 +23,6 @@ import { z } from 'astro/zod';
  * - `wpImporter` - An object with `enabled` and `endpoint` properties for the app's configuration.
  */
 export declare const AppsConfigSchema: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodObject<{
-    /**
-     * Astro DB LibSQL Viewer App Config
-     */
-    libSQLViewer: z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
-        endpoint: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    }, "strip", z.ZodTypeAny, {
-        endpoint: string;
-    }, {
-        endpoint?: string | undefined;
-    }>]>;
     /**
      * StudioCMS WP API Importer App Config
      */
@@ -44,32 +34,19 @@ export declare const AppsConfigSchema: z.ZodEffects<z.ZodDefault<z.ZodOptional<z
         endpoint?: string | undefined;
     }>]>;
 }, "strip", z.ZodTypeAny, {
-    libSQLViewer: boolean | {
-        endpoint: string;
-    };
     wpImporter: boolean | {
         endpoint: string;
     };
 }, {
-    libSQLViewer: boolean | {
-        endpoint?: string | undefined;
-    };
     wpImporter: boolean | {
         endpoint?: string | undefined;
     };
 }>>>, {
-    libSQLViewer: {
-        enabled: boolean;
-        endpoint: string;
-    };
     wpImporter: {
         enabled: boolean;
         endpoint: string;
     };
 }, {
-    libSQLViewer: boolean | {
-        endpoint?: string | undefined;
-    };
     wpImporter: boolean | {
         endpoint?: string | undefined;
     };
@@ -92,16 +69,6 @@ export declare const StudioCMSDevAppsSchema: z.ZodDefault<z.ZodOptional<z.ZodObj
     endpoint: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     appsConfig: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        /**
-         * Astro DB LibSQL Viewer App Config
-         */
-        libSQLViewer: z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
-            endpoint: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        }, "strip", z.ZodTypeAny, {
-            endpoint: string;
-        }, {
-            endpoint?: string | undefined;
-        }>]>;
         /**
          * StudioCMS WP API Importer App Config
          */
@@ -113,32 +80,19 @@ export declare const StudioCMSDevAppsSchema: z.ZodDefault<z.ZodOptional<z.ZodObj
             endpoint?: string | undefined;
         }>]>;
     }, "strip", z.ZodTypeAny, {
-        libSQLViewer: boolean | {
-            endpoint: string;
-        };
         wpImporter: boolean | {
             endpoint: string;
         };
     }, {
-        libSQLViewer: boolean | {
-            endpoint?: string | undefined;
-        };
         wpImporter: boolean | {
             endpoint?: string | undefined;
         };
     }>>>, {
-        libSQLViewer: {
-            enabled: boolean;
-            endpoint: string;
-        };
         wpImporter: {
             enabled: boolean;
             endpoint: string;
         };
     }, {
-        libSQLViewer: boolean | {
-            endpoint?: string | undefined;
-        };
         wpImporter: boolean | {
             endpoint?: string | undefined;
         };
@@ -147,10 +101,6 @@ export declare const StudioCMSDevAppsSchema: z.ZodDefault<z.ZodOptional<z.ZodObj
     endpoint: string;
     verbose: boolean;
     appsConfig: {
-        libSQLViewer: {
-            enabled: boolean;
-            endpoint: string;
-        };
         wpImporter: {
             enabled: boolean;
             endpoint: string;
@@ -160,9 +110,6 @@ export declare const StudioCMSDevAppsSchema: z.ZodDefault<z.ZodOptional<z.ZodObj
     endpoint?: string | undefined;
     verbose?: boolean | undefined;
     appsConfig?: {
-        libSQLViewer: boolean | {
-            endpoint?: string | undefined;
-        };
         wpImporter: boolean | {
             endpoint?: string | undefined;
         };

package/dist/schema/index.js

@@ -1,14 +1,5 @@
 import { z } from "astro/zod";
 const AppsConfigSchema = z.object({
-  /**
-   * Astro DB LibSQL Viewer App Config
-   */
-  libSQLViewer: z.union([
-    z.boolean(),
-    z.object({
-      endpoint: z.string().optional().default("outerbase")
-    })
-  ]),
   /**
    * StudioCMS WP API Importer App Config
    */
@@ -19,23 +10,15 @@ const AppsConfigSchema = z.object({
     })
   ])
 }).optional().default({
-  wpImporter: { endpoint: "wp-api-importer" },
-  libSQLViewer: { endpoint: "outerbase" }
+  wpImporter: { endpoint: "wp-api-importer" }
 }).transform((val) => {
-  let libSQL;
   let wpAPI;
-  if (typeof val.libSQLViewer === "boolean") {
-    libSQL = { enabled: val.libSQLViewer, endpoint: "outerbase" };
-  } else {
-    libSQL = { enabled: true, endpoint: val.libSQLViewer.endpoint };
-  }
   if (typeof val.wpImporter === "boolean") {
     wpAPI = { enabled: val.wpImporter, endpoint: "wp-api-importer" };
   } else {
     wpAPI = { enabled: true, endpoint: val.wpImporter.endpoint };
   }
   return {
-    libSQLViewer: libSQL,
     wpImporter: wpAPI
   };
 });

package/dist/virt.d.ts

@@ -1,15 +1,9 @@
-/// <reference types="@astrojs/db" />
 /// <reference types="studiocms/v/types" />
 
 declare module 'virtual:studiocms-devapps/endpoints' {
 	export const wpAPIEndpoint: string;
-	export const libsqlEndpoint: string;
 }
 
 declare module 'virtual:studiocms-devapps/config' {
 	export const userProjectRoot: string;
-	export const dbEnv: {
-		remoteUrl: string;
-		token: string;
-	};
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@studiocms/devapps",
-  "version": "0.1.0-beta.30",
-  "description": "A dedicated CMS for Astro DB. Built from the ground up by the Astro community.",
+  "version": "0.1.0-beta.31",
+  "description": "Devapps for StudioCMS Astro projects, including a WordPress importer.",
   "author": {
     "name": "withstudiocms",
     "url": "https://studiocms.dev"
@@ -20,18 +20,12 @@
   "license": "MIT",
   "keywords": [
     "astro",
-    "astrodb",
-    "astrolicious",
     "astro-integration",
     "studiocms",
     "withastro",
     "wordpress",
     "wordpress-import",
     "wordpress-importer",
-    "libsql",
-    "libsql-viewer",
-    "libsql-client",
-    "libsqlstudio",
     "devapp",
     "astro-devapp",
     "astro-devtoolbarapp"
@@ -65,16 +59,11 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@astrojs/db": ">=0.17.2",
     "astro": "^5.12.9",
-    "effect": "^3.19.2",
+    "effect": "^3.19.9",
     "vite": "^6.3.4",
-    "studiocms": "0.1.0-beta.30"
-  },
-  "peerDependenciesMeta": {
-    "studiocms": {
-      "optional": true
-    }
+    "@withstudiocms/kysely": "0.1.0-beta.1",
+    "studiocms": "0.1.0-beta.31"
   },
   "scripts": {
     "build": "buildkit build 'src/**/*.{ts,astro,css,json,png,d.ts}'",

package/dist/apps/libsql-viewer.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("astro").DevToolbarApp;
-export default _default;

package/dist/apps/libsql-viewer.js

@@ -1,32 +0,0 @@
-import { libsqlEndpoint } from "virtual:studiocms-devapps/endpoints";
-import { defineToolbarApp } from "astro/toolbar";
-import { closeOnOutsideClick } from "../utils/app-utils.js";
-var libsql_viewer_default = defineToolbarApp({
-  init(canvas, eventTarget) {
-    const appWindow = document.createElement("astro-dev-toolbar-window");
-    appWindow.style.width = "90%";
-    appWindow.style.height = "100%";
-    appWindow.style.marginLeft = "1rem";
-    appWindow.style.marginRight = "1rem";
-    appWindow.style.padding = "0";
-    appWindow.style.border = "none";
-    appWindow.style.overflow = "hidden";
-    appWindow.style.borderRadius = "0.5rem";
-    appWindow.style.boxShadow = "0 0 1rem rgba(0, 0, 0, 0.1)";
-    closeOnOutsideClick(eventTarget);
-    const viewerIframe = document.createElement("iframe");
-    viewerIframe.src = libsqlEndpoint;
-    viewerIframe.id = "sqlIframe";
-    viewerIframe.title = "libSQL Database Viewer";
-    Object.assign(viewerIframe.style, {
-      height: "100%",
-      width: "100%",
-      border: "1px solid rgba(27, 30, 36, 1)"
-    });
-    appWindow.appendChild(viewerIframe);
-    canvas.appendChild(appWindow);
-  }
-});
-export {
-  libsql_viewer_default as default
-};

package/dist/routes/outerbase.astro

@@ -1,118 +0,0 @@
----
-import { dbEnv } from 'virtual:studiocms-devapps/config';
-
-/**
- * Generates the source URL for an iframe based on the provided database URL.
- *
- * @param dbUrl - The URL of the database.
- * @returns The source URL for the iframe. If the database URL contains 'turso.io',
- *          it returns `tursoURL`. Otherwise, it returns `sqlLiteUrl`.
- */
-function getIFrameSrc(dbUrl: string) {
-	if (dbUrl.includes('turso.io')) {
-		return 'https://studio.outerbase.com/embed/turso?theme=dark';
-	}
-	return 'https://studio.outerbase.com/embed/turso?theme=dark';
-}
----
-<html>
-    <head>
-        <style is:global>
-            astro-dev-toolbar {
-                display: none;
-            }
-        </style>
-    </head>
-    <body style="margin: 0; padding: 0; overflow: hidden;">
-        <iframe id="sqlIframe"
-            style="width: 100%; height: 100vh; border: none;"
-            src={getIFrameSrc(dbEnv.remoteUrl)}
-            title="Outerbase Studio"
-            allow="clipboard-read; clipboard-write"
-            data-dburl={dbEnv.remoteUrl}
-            data-dbtoken={dbEnv.token}
-            />
-
-        <script>
-            // @ts-ignore
-            import { createClient } from 'https://esm.sh/@libsql/client@0.14.0/web';
-            // @ts-ignore
-            import { transformTursoResult } from 'https://esm.sh/@outerbase/sdk-transform@1.0.7';
-
-            interface ClientRequest {
-                type: 'query' | 'transaction';
-                id: number;
-                statement?: string;
-                statements?: string[];
-            }
-
-            const iframe = document.querySelector('#sqlIframe') as HTMLIFrameElement;
-
-            const dbUrl = iframe.dataset.dburl;
-            const dbToken = iframe.dataset.dbtoken;
-
-            const client = createClient({
-                // biome-ignore lint/style/noNonNullAssertion: <explanation>
-                url: dbUrl!,
-                // biome-ignore lint/style/noNonNullAssertion: <explanation>
-                authToken: dbToken!,
-                intMode: 'bigint',
-            });
-
-            // Event listener to handle postMessage events
-            window.addEventListener('message', async (e: MessageEvent<ClientRequest>) => {
-                const contentWindow = iframe.contentWindow;
-
-                if (contentWindow && e.data) {
-                    const { type, id, statement, statements } = e.data;
-
-                    if (type === 'query' && statement) {
-                        // Execute a single SQL query
-                        try {
-                            const result = await client.execute(statement);
-                            contentWindow.postMessage(
-                                {
-                                    type,
-                                    id,
-                                    data: transformTursoResult(result),
-                                },
-                                '*'
-                            );
-                        } catch (err) {
-                            contentWindow.postMessage(
-                                {
-                                    type,
-                                    id,
-                                    error: (err as Error).message,
-                                },
-                                '*'
-                            );
-                        }
-                    } else if (type === 'transaction' && statements) {
-                        // Execute a batch of SQL statements in a transaction
-                        try {
-                            const result = await client.batch(statements, 'write');
-                            contentWindow.postMessage(
-                                {
-                                    type,
-                                    id,
-                                    data: result.map(transformTursoResult),
-                                },
-                                '*'
-                            );
-                        } catch (err) {
-                            contentWindow.postMessage(
-                                {
-                                    type,
-                                    id,
-                                    error: (err as Error).message,
-                                },
-                                '*'
-                            );
-                        }
-                    }
-                }
-            });
-        </script>
-    </body>
-</html>