@withstudiocms/sdk 0.0.0-beta.0 → 0.1.0-beta.1

package/dist/modules/rest_api/index.js

@@ -0,0 +1,113 @@
+import { Effect, Schema } from "@withstudiocms/effect";
+import { StudioCMSAPIKeys, StudioCMSPermissions } from "@withstudiocms/kysely";
+import { DBClientLive } from "../../context.js";
+import { SDKGenerators } from "../util/generators.js";
+const SDKRestAPIModule = Effect.gen(function* () {
+  const [{ withCodec, withEncoder }, { generateToken }] = yield* Effect.all([
+    DBClientLive,
+    SDKGenerators
+  ]);
+  const _getTokensForUser = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.Array(StudioCMSAPIKeys.Select),
+    callbackFn: (db, userId) => db(
+      (client) => client.selectFrom("StudioCMSAPIKeys").selectAll().where("userId", "=", userId).execute()
+    )
+  });
+  const _newToken = withCodec({
+    encoder: StudioCMSAPIKeys.Insert,
+    decoder: StudioCMSAPIKeys.Select,
+    callbackFn: (db, tokenData) => db(
+      (client) => client.insertInto("StudioCMSAPIKeys").values(tokenData).returningAll().executeTakeFirstOrThrow()
+    )
+  });
+  const _deleteToken = withEncoder({
+    encoder: Schema.Struct({
+      userId: Schema.String,
+      tokenId: Schema.String
+    }),
+    callbackFn: (db, { userId, tokenId }) => db(
+      (client) => client.deleteFrom("StudioCMSAPIKeys").where("userId", "=", userId).where("id", "=", tokenId).execute()
+    )
+  });
+  const _getByKey = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSAPIKeys.Select),
+    callbackFn: (db, key) => db(
+      (client) => client.selectFrom("StudioCMSAPIKeys").selectAll().where("key", "=", key).executeTakeFirst()
+    )
+  });
+  const _getKeyPermissions = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSPermissions.Select),
+    callbackFn: (db, userId) => db(
+      (client) => client.selectFrom("StudioCMSPermissions").selectAll().where("user", "=", userId).executeTakeFirst()
+    )
+  });
+  const _createNewTokenForUser = Effect.fn(
+    (userId, description) => generateToken(userId, true).pipe(
+      Effect.flatMap(
+        (key) => _newToken({
+          id: crypto.randomUUID(),
+          key,
+          userId,
+          description
+        })
+      )
+    )
+  );
+  const _verifyToken = Effect.fn(
+    (key) => Effect.gen(function* () {
+      const apiKeyRecord = yield* _getByKey(key);
+      if (!apiKeyRecord) return false;
+      const permissionsRecord = yield* _getKeyPermissions(apiKeyRecord.userId);
+      if (!permissionsRecord) return false;
+      return {
+        userId: apiKeyRecord.userId,
+        key: apiKeyRecord.key,
+        rank: permissionsRecord.rank
+      };
+    })
+  );
+  const tokens = {
+    /**
+     * Retrieves all API tokens for a specific user.
+     *
+     * @param userId - The ID of the user whose tokens are to be retrieved.
+     * @returns An Effect that resolves to an array of API keys for the user.
+     * @throws {LibSQLDatabaseError} If a database error occurs during the operation.
+     */
+    get: _getTokensForUser,
+    /**
+     * Creates a new API token for a user with the specified description.
+     *
+     * @param userId - The ID of the user for whom to create the token.
+     * @param description - A description for the API key.
+     * @returns An Effect that resolves to the created API key record.
+     * @throws {LibSQLDatabaseError} If a database error occurs during the operation.
+     */
+    new: _createNewTokenForUser,
+    /**
+     * Deletes an API token for a user by its ID.
+     *
+     * @param userId - The ID of the user whose token is to be deleted.
+     * @param tokenId - The ID of the API token to delete.
+     * @returns An Effect that resolves when the token is successfully deleted.
+     * @throws {LibSQLDatabaseError} If a database error occurs during the operation.
+     */
+    delete: _deleteToken,
+    /**
+     * Verifies an API token and retrieves associated user information.
+     *
+     * @param key - The API token to verify.
+     * @returns An Effect that resolves to user information if the token is valid, or false if invalid.
+     */
+    verify: _verifyToken
+  };
+  return { tokens };
+});
+var rest_api_default = SDKRestAPIModule;
+export {
+  SDKRestAPIModule,
+  rest_api_default as default
+};

package/dist/modules/update/index.d.ts

@@ -0,0 +1,184 @@
+import { Effect } from '@withstudiocms/effect';
+import { StudioCMSPageContent, StudioCMSPageData } from '@withstudiocms/kysely';
+import CacheService from '../../cache.js';
+import { DBClientLive } from '../../context.js';
+/**
+ * CombinedPageUpdateData
+ *
+ * Type representing the combined data required to update both page data and page content.
+ */
+type CombinedPageUpdateData = {
+    pageData: (typeof StudioCMSPageData.Update)['Type'];
+    pageContent: (typeof StudioCMSPageContent.Update)['Type'];
+};
+/**
+ * SDKUpdateModule
+ *
+ * Effect generator that constructs and returns the SDK "UPDATE" module containing all update-related operations
+ * for the StudioCMS domain. Each operation is implemented as an Effect and typically combines:
+ * - a DB update operation (wrapped with a codec for runtime encode/decode/validation),
+ * - optional cache invalidation or cache refresh,
+ * - and retrieval of the fresh resource via the GET module when appropriate.
+ *
+ * @module SDKUpdateModule
+ *
+ * @remarks
+ * - Dependencies resolved by the generator: DBClientLive, CacheService, SDKClearModule, SDKGetModule, SDKConfigModule.
+ * - DB operations are created via withCodec with corresponding encoder/decoder codecs (e.g. StudioCMSPageContent, StudioCMSPageData, StudioCMSPermissions, etc.).
+ * - Cache-related operations include clearing/invalidation of folder tree/list caches, page-specific cache deletion, and npm package cache tag invalidation.
+ * - Composite helpers coordinate multi-step flows, e.g. updating page content + page data + deleting the page cache, then returning the fresh page via GET.
+ * - All operations are effectful and intended to be executed inside the Effect runtime; callers should compose and run them using the Effect primitives provided by the environment.
+ *
+ * @returns {{
+ *   pageContent: Effect, tags: Effect, categories: Effect, permissions: Effect,
+ *   folderTree: Effect, folderList: Effect, folder: Effect,
+ *   latestVersion: Effect, siteConfig: Effect,
+ *   page: { byId: Effect, bySlug: Effect }
+ * }}
+ * An object exposing update operations:
+ * - pageContent, tags, categories, permissions: DB update Effects returning the updated record.
+ * - folderTree, folderList: Effects that refresh corresponding caches.
+ * - folder: updates a folder entry and invalidates/refreshes folder caches.
+ * - latestVersion: invalidates npm package cache tags and fetches the latest package version.
+ * - siteConfig: forwards to CONFIG.siteConfig.update.
+ * - page.byId: updates page data and content, deletes the page cache, refreshes folder caches, then returns the updated page.
+ * - page.bySlug: resolves the page id by slug and delegates to page.byId.
+ *
+ * @example
+ * // Typical usage inside an Effect:
+ * // yield* Effect.flatMap(UPDATE.page.byId('pageId', combinedPageUpdateData))
+ *
+ * @threadSafety
+ * Effects encapsulate async side effects; callers should treat composite updates as atomic logical operations but not assume cross-operation DB transactions unless provided by the DB client.
+ *
+ * @errors
+ * - DB client errors (e.g. executeTakeFirstOrThrow) propagate as Effect failures.
+ * - Codec validation errors are raised if supplied data does not conform to the expected codec schemas.
+ *
+ * @see SDKGetModule for read operations
+ * @see SDKClearModule for explicit cache clearing operations
+ */
+export declare const SDKUpdateModule: Effect.Effect<{
+    /**
+     * Update Page Content
+     *
+     * @param data - The page content data to update.
+     * @returns The updated page content.
+     */
+    pageContent: (input: {
+        readonly id: string;
+        readonly contentId: string;
+        readonly contentLang: string;
+        readonly content: string;
+    }) => Effect.Effect<{
+        readonly id: string;
+        readonly contentId: string;
+        readonly contentLang: string;
+        readonly content: string;
+    }, import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Tag
+     *
+     * @param data - The tag data to update.
+     * @returns The updated tag.
+     */
+    tags: (input: {
+        readonly name: string;
+        readonly id: number;
+        readonly description: string;
+        readonly slug: string;
+        readonly meta: string;
+    }) => Effect.Effect<{
+        readonly name: string;
+        readonly id: number;
+        readonly description: string;
+        readonly slug: string;
+        readonly meta: {
+            readonly [x: string]: unknown;
+        };
+    }, import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Category
+     *
+     * @param data - The category data to update.
+     * @returns The updated category.
+     */
+    categories: (input: {
+        readonly parent?: number | null | undefined;
+        readonly name: string;
+        readonly id: number;
+        readonly description: string;
+        readonly slug: string;
+        readonly meta: string;
+    }) => Effect.Effect<{
+        readonly name: string;
+        readonly id: number;
+        readonly parent: number | null | undefined;
+        readonly description: string;
+        readonly slug: string;
+        readonly meta: {
+            readonly [x: string]: unknown;
+        };
+    }, import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Permissions
+     *
+     * @param data - The permissions data to update.
+     * @returns The updated permissions.
+     */
+    permissions: (input: {
+        readonly user: string;
+        readonly rank: "owner" | "admin" | "editor" | "visitor" | "unknown";
+    }) => Effect.Effect<{
+        readonly user: string;
+        readonly rank: "owner" | "admin" | "editor" | "visitor" | "unknown";
+    }, import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Folder Tree Cache
+     */
+    folderTree: Effect.Effect<import("../../types.js").FolderNode[], import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/folderTree.js").FolderTreeError, never>;
+    /**
+     * Update Folder List Cache
+     */
+    folderList: Effect.Effect<import("../../types.js").FolderListItem[], import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Folder Entry and Invalidate Related Caches
+     *
+     * @param data - The folder entry data to update.
+     * @returns The updated folder entry.
+     */
+    folder: (data: {
+        readonly name: string;
+        readonly id: string;
+        readonly parent: string | null | undefined;
+    }) => Effect.Effect<{
+        readonly name: string;
+        readonly id: string;
+        readonly parent: string | null | undefined;
+    }, import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/folderTree.js").FolderTreeError, never>;
+    /**
+     * Update Latest NPM Package Version
+     */
+    latestVersion: () => Effect.Effect<{
+        version: string;
+        lastCacheUpdate: Date;
+    }, import("effect/Cause").UnknownException | Error | import("effect/ParseResult").ParseError, never>;
+    /**
+     * Update Site Configuration
+     */
+    siteConfig: (data: import("../../types.js").ConfigFinal<import("../../types.js").StudioCMSSiteConfig>) => Effect.Effect<import("../../types.js").DynamicConfigEntry<import("../../types.js").StudioCMSSiteConfig>, import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Page Operations
+     */
+    page: {
+        /**
+         * Update Page by ID
+         */
+        byId: (pageId: string, data: CombinedPageUpdateData) => Effect.Effect<import("../../types.js").CombinedPageData | undefined, import("effect/ParseResult").ParseError | import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").QueryParseError | import("@withstudiocms/kysely/core/errors").QueryError | import("@withstudiocms/kysely/core/errors").NotFoundError | import("../util/folderTree.js").FolderTreeError | import("../util/collectors.js").CollectorError | import("../get/index.js").PaginateError, never>;
+        /**
+         * Update Page by Slug
+         */
+        bySlug: (slug: string, data: CombinedPageUpdateData) => Effect.Effect<import("../../types.js").CombinedPageData | undefined, import("effect/ParseResult").ParseError | import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/folderTree.js").FolderTreeError | import("../util/collectors.js").CollectorError | import("../get/index.js").PaginateError, never>;
+    };
+}, never, DBClientLive | import("../../context.js").SDKDefaults | CacheService | import("@withstudiocms/effect").Deepmerge>;
+export default SDKUpdateModule;

package/dist/modules/update/index.js

@@ -0,0 +1,174 @@
+import { Effect, Schema } from "@withstudiocms/effect";
+import {
+  StudioCMSPageContent,
+  StudioCMSPageData,
+  StudioCMSPageDataCategories,
+  StudioCMSPageDataTags,
+  StudioCMSPageFolderStructure,
+  StudioCMSPermissions
+} from "@withstudiocms/kysely";
+import CacheService from "../../cache.js";
+import { cacheKeyGetters, cacheTags } from "../../consts.js";
+import { DBClientLive } from "../../context.js";
+import SDKClearModule from "../clear/index.js";
+import SDKConfigModule from "../config/index.js";
+import SDKGetModule from "../get/index.js";
+const SDKUpdateModule = Effect.gen(function* () {
+  const [{ withCodec }, CACHE, CLEAR, GET, CONFIG] = yield* Effect.all([
+    DBClientLive,
+    CacheService,
+    SDKClearModule,
+    SDKGetModule,
+    SDKConfigModule
+  ]);
+  const _updatePageContent = withCodec({
+    encoder: StudioCMSPageContent.Update,
+    decoder: StudioCMSPageContent.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.updateTable("StudioCMSPageContent").set(data).where("id", "=", data.id).returningAll().executeTakeFirstOrThrow()
+    )
+  });
+  const _updateTag = withCodec({
+    encoder: StudioCMSPageDataTags.Update,
+    decoder: StudioCMSPageDataTags.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.updateTable("StudioCMSPageDataTags").set(data).where("id", "=", data.id).returningAll().executeTakeFirstOrThrow()
+    )
+  });
+  const _updateCategory = withCodec({
+    encoder: StudioCMSPageDataCategories.Update,
+    decoder: StudioCMSPageDataCategories.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.updateTable("StudioCMSPageDataCategories").set(data).where("id", "=", data.id).returningAll().executeTakeFirstOrThrow()
+    )
+  });
+  const _updatePermission = withCodec({
+    encoder: StudioCMSPermissions.Update,
+    decoder: StudioCMSPermissions.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.updateTable("StudioCMSPermissions").set(data).where("user", "=", data.user).returningAll().executeTakeFirstOrThrow()
+    )
+  });
+  const _updateFolderEntry = withCodec({
+    encoder: StudioCMSPageFolderStructure.Update,
+    decoder: StudioCMSPageFolderStructure.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.updateTable("StudioCMSPageFolderStructure").set(data).where("id", "=", data.id).returningAll().executeTakeFirstOrThrow()
+    )
+  });
+  const _updatePageDataEntry = withCodec({
+    encoder: StudioCMSPageData.Update,
+    decoder: StudioCMSPageData.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.updateTable("StudioCMSPageData").set(data).where("id", "=", data.id).returningAll().executeTakeFirstOrThrow()
+    )
+  });
+  const _findPageDataBySlug = withCodec({
+    encoder: Schema.String,
+    decoder: StudioCMSPageData.Select,
+    callbackFn: (db, slug) => db(
+      (client) => client.selectFrom("StudioCMSPageData").where("slug", "=", slug).selectAll().executeTakeFirstOrThrow()
+    )
+  });
+  const _updateFolderTree = CLEAR.folderTree.pipe(Effect.flatMap(GET.folderTree));
+  const _updateFolderList = CLEAR.folderList.pipe(Effect.flatMap(GET.folderList));
+  const _updateFolderEntryAndInvalidate = Effect.fn(
+    (data) => _updateFolderEntry(data).pipe(
+      Effect.flatMap((src) => _updateFolderTree.pipe(Effect.as(src))),
+      Effect.flatMap((src) => _updateFolderList.pipe(Effect.as(src)))
+    )
+  );
+  const _updateLatestVersion = Effect.fn(
+    () => CACHE.invalidateTags(cacheTags.npmPackage).pipe(Effect.flatMap(GET.latestVersion))
+  );
+  const _updateFolderTreeAndList = Effect.all([_updateFolderTree, _updateFolderList]);
+  const _updatePageById = Effect.fn(
+    (pageId, data) => Effect.all([
+      _updatePageDataEntry(data.pageData),
+      _updatePageContent(data.pageContent),
+      CACHE.delete(cacheKeyGetters.page(pageId))
+    ]).pipe(
+      Effect.tap(() => _updateFolderTreeAndList),
+      Effect.flatMap(() => GET.page.byId(pageId))
+    )
+  );
+  const _findPageIdBySlug = Effect.fn(
+    (slug) => _findPageDataBySlug(slug).pipe(Effect.map(({ id }) => id))
+  );
+  const _updatePageByIdPiped = (data) => Effect.fn((id) => _updatePageById(id, data));
+  const _updatePageBySlug = Effect.fn(
+    (slug, data) => _findPageIdBySlug(slug).pipe(Effect.flatMap(_updatePageByIdPiped(data)))
+  );
+  const UPDATE = {
+    /**
+     * Update Page Content
+     *
+     * @param data - The page content data to update.
+     * @returns The updated page content.
+     */
+    pageContent: _updatePageContent,
+    /**
+     * Update Tag
+     *
+     * @param data - The tag data to update.
+     * @returns The updated tag.
+     */
+    tags: _updateTag,
+    /**
+     * Update Category
+     *
+     * @param data - The category data to update.
+     * @returns The updated category.
+     */
+    categories: _updateCategory,
+    /**
+     * Update Permissions
+     *
+     * @param data - The permissions data to update.
+     * @returns The updated permissions.
+     */
+    permissions: _updatePermission,
+    /**
+     * Update Folder Tree Cache
+     */
+    folderTree: _updateFolderTree,
+    /**
+     * Update Folder List Cache
+     */
+    folderList: _updateFolderList,
+    /**
+     * Update Folder Entry and Invalidate Related Caches
+     *
+     * @param data - The folder entry data to update.
+     * @returns The updated folder entry.
+     */
+    folder: _updateFolderEntryAndInvalidate,
+    /**
+     * Update Latest NPM Package Version
+     */
+    latestVersion: _updateLatestVersion,
+    /**
+     * Update Site Configuration
+     */
+    siteConfig: CONFIG.siteConfig.update,
+    /**
+     * Page Operations
+     */
+    page: {
+      /**
+       * Update Page by ID
+       */
+      byId: _updatePageById,
+      /**
+       * Update Page by Slug
+       */
+      bySlug: _updatePageBySlug
+    }
+  };
+  return UPDATE;
+});
+var update_default = SDKUpdateModule;
+export {
+  SDKUpdateModule,
+  update_default as default
+};