@withstudiocms/sdk 0.0.0-beta.0 → 0.1.0

package/dist/modules/get/index.js

@@ -0,0 +1,579 @@
+import { Effect, Schema } from "@withstudiocms/effect";
+import CacheService from "../../cache.js";
+import { cacheKeyGetters, cacheTags } from "../../consts.js";
+import { DBClientLive, SDKDefaults } from "../../context.js";
+import {
+  StudioCMSPageData,
+  StudioCMSPageDataCategories,
+  StudioCMSPageDataTags,
+  StudioCMSPageFolderStructure,
+  StudioCMSPermissions,
+  StudioCMSUsersTable
+} from "../../tables.js";
+import SDKConfigModule from "../config/index.js";
+import { SDKCollectors } from "../util/collectors.js";
+import { SDKFolderTree } from "../util/folderTree.js";
+import { GetFromNPM } from "../util/getFromNPM.js";
+import { SDKUsers } from "../util/users.js";
+const ranks = ["owner", "admin", "editor", "visitor"];
+class PaginateError extends Error {
+  _tag = "PaginateError";
+}
+class KillSwitch {
+  _tag = "KillSwitch";
+}
+const SDKGetModule = Effect.gen(function* () {
+  const [
+    { withCodec, withDecoder },
+    { verifyRank, combineRanks },
+    { collectUserData, collectPageData },
+    { siteConfig: sdkSiteConfig },
+    { GhostUserDefaults },
+    { memoize },
+    { buildFolderTree, getAvailableFolders, addPageToFolderTree },
+    { getVersion }
+  ] = yield* Effect.all([
+    DBClientLive,
+    SDKUsers,
+    SDKCollectors,
+    SDKConfigModule,
+    SDKDefaults,
+    CacheService,
+    SDKFolderTree,
+    GetFromNPM
+  ]);
+  const _getUsers = withDecoder({
+    decoder: Schema.Array(StudioCMSUsersTable.Select),
+    callbackFn: (db) => db((client) => client.selectFrom("StudioCMSUsersTable").selectAll().execute())
+  });
+  const _getUserById = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSUsersTable.Select),
+    callbackFn: (db, userId) => db(
+      (client) => client.selectFrom("StudioCMSUsersTable").selectAll().where("id", "=", userId).executeTakeFirst()
+    )
+  });
+  const _getUserByUsername = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSUsersTable.Select),
+    callbackFn: (db, username) => db(
+      (client) => client.selectFrom("StudioCMSUsersTable").selectAll().where("username", "=", username).executeTakeFirst()
+    )
+  });
+  const _getUserByEmail = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSUsersTable.Select),
+    callbackFn: (db, email) => db(
+      (client) => client.selectFrom("StudioCMSUsersTable").selectAll().where("email", "=", email).executeTakeFirst()
+    )
+  });
+  const _getCurrentPermissions = withDecoder({
+    decoder: Schema.Array(StudioCMSPermissions.Select),
+    callbackFn: (db) => db((client) => client.selectFrom("StudioCMSPermissions").selectAll().execute())
+  });
+  const _getFolder = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSPageFolderStructure.Select),
+    callbackFn: (db, folderId) => db(
+      (client) => client.selectFrom("StudioCMSPageFolderStructure").selectAll().where("id", "=", folderId).executeTakeFirst()
+    )
+  });
+  const _getAllPagesPaginated = withCodec({
+    encoder: Schema.Struct({
+      limit: Schema.Number,
+      offset: Schema.Number
+    }),
+    decoder: Schema.Array(StudioCMSPageData.Select),
+    callbackFn: (db, { limit, offset }) => db(
+      (client) => client.selectFrom("StudioCMSPageData").selectAll().orderBy("title", "asc").limit(limit).offset(offset).execute()
+    )
+  });
+  const _getAllPagesBase = withDecoder({
+    decoder: Schema.Array(StudioCMSPageData.Select),
+    callbackFn: (db) => db(
+      (client) => client.selectFrom("StudioCMSPageData").selectAll().orderBy("title", "asc").execute()
+    )
+  });
+  const _getPageByIdFromDB = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSPageData.Select),
+    callbackFn: (db, pageId) => db(
+      (client) => client.selectFrom("StudioCMSPageData").selectAll().where("id", "=", pageId).executeTakeFirst()
+    )
+  });
+  const _getPageBySlugFromDB = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSPageData.Select),
+    callbackFn: (db, slug) => db(
+      (client) => client.selectFrom("StudioCMSPageData").selectAll().where("slug", "=", slug).executeTakeFirst()
+    )
+  });
+  const _getPageByPackageFromDB = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSPageData.Select),
+    callbackFn: (db, packageId) => db(
+      (client) => client.selectFrom("StudioCMSPageData").selectAll().where("package", "=", packageId).executeTakeFirst()
+    )
+  });
+  const _getFolderByNameOrId = withCodec({
+    encoder: Schema.String,
+    decoder: StudioCMSPageFolderStructure.Select,
+    callbackFn: (db, folderId) => db(
+      (client) => client.selectFrom("StudioCMSPageFolderStructure").selectAll().where((eb) => eb.or([eb("id", "=", folderId), eb("name", "=", folderId)])).executeTakeFirstOrThrow()
+    )
+  });
+  const _verifyRank = (rank) => Effect.fn(
+    ({
+      users,
+      permissions
+    }) => verifyRank(users, permissions, rank)
+  );
+  const _getPermissionsByRank = (rank) => Effect.all({
+    permissions: _getCurrentPermissions(),
+    users: _getUsers()
+  }).pipe(Effect.flatMap(_verifyRank(rank)));
+  const _combineRanks = ([rank, users]) => combineRanks(rank, users);
+  const _processAndVerifyRanks = (ranks2) => Effect.fn(
+    ({
+      users,
+      permissions
+    }) => Effect.forEach(
+      ranks2,
+      (rank) => verifyRank(users, permissions, rank).pipe(Effect.map((res) => [rank, res]))
+    )
+  );
+  const _getCombinedRanks = Effect.fn(
+    () => Effect.all({
+      permissions: _getCurrentPermissions(),
+      users: _getUsers()
+    }).pipe(
+      Effect.flatMap(_processAndVerifyRanks(ranks)),
+      Effect.flatMap(Effect.forEach(_combineRanks)),
+      Effect.map((data) => data.flat())
+    )
+  );
+  const _filterOutGhostUser = Effect.fn(
+    (users) => Effect.succeed(users.filter((user) => user.id !== GhostUserDefaults.id))
+  );
+  const _getAllUsers = Effect.fn(
+    () => _getUsers().pipe(
+      Effect.flatMap(_filterOutGhostUser),
+      Effect.flatMap(Effect.forEach(collectUserData))
+    )
+  );
+  const _getUserByIdExposed = Effect.fn(
+    (userId) => _getUserById(userId).pipe(
+      Effect.flatMap((user) => user ? collectUserData(user) : Effect.succeed(void 0))
+    )
+  );
+  const _getUserByUsernameExposed = Effect.fn(
+    (username) => _getUserByUsername(username).pipe(
+      Effect.flatMap((user) => user ? collectUserData(user) : Effect.succeed(void 0))
+    )
+  );
+  const _getUserByEmailExposed = Effect.fn(
+    (email) => _getUserByEmail(email).pipe(
+      Effect.flatMap((user) => user ? collectUserData(user) : Effect.succeed(void 0))
+    )
+  );
+  const validatePagination = Effect.fn(function* (paginate) {
+    if (paginate.limit < 0 || paginate.offset < 0) {
+      return yield* Effect.fail(new PaginateError("Pagination values must be non-negative"));
+    }
+    if (paginate.limit === 0) {
+      paginate.limit = 10;
+    }
+    return paginate;
+  });
+  const __filterPagesByDraft = Effect.fn(
+    (pages, includeDrafts) => Effect.succeed(pages.filter(({ draft }) => includeDrafts || draft !== true))
+  );
+  function convertCombinedPageDataToMetaOnly(data) {
+    if (Array.isArray(data)) {
+      return data.map(
+        ({ defaultContent, multiLangContent, ...data2 }) => data2
+      );
+    }
+    const { defaultContent: _dump1, multiLangContent: _dump2, ...metaOnlyData } = data;
+    return metaOnlyData;
+  }
+  const __getPagesPossiblyPaginated = (paginate) => paginate ? validatePagination(paginate).pipe(Effect.flatMap(_getAllPagesPaginated)) : _getAllPagesBase();
+  function _getAllPages(includeDrafts = false, metaOnly = false, paginate) {
+    return __getPagesPossiblyPaginated(paginate).pipe(
+      Effect.flatMap(
+        (pagesRaw) => Effect.all({
+          pages: __filterPagesByDraft(pagesRaw, includeDrafts),
+          tree: GET.folderTree()
+        })
+      ),
+      Effect.flatMap(
+        ({ pages, tree }) => Effect.forEach(
+          pages,
+          (page) => memoize(cacheKeyGetters.page(page.id), collectPageData(page, tree), {
+            tags: cacheTags.pages
+          })
+        )
+      ),
+      Effect.map((data) => metaOnly ? convertCombinedPageDataToMetaOnly(data) : data)
+    );
+  }
+  function _getPageById(id, metaOnly = false) {
+    return _getPageByIdFromDB(id).pipe(
+      Effect.flatMap((page) => page ? Effect.succeed(page) : Effect.fail(new KillSwitch())),
+      Effect.flatMap(
+        (page) => GET.folderTree().pipe(
+          Effect.flatMap(
+            (tree) => memoize(cacheKeyGetters.page(page.id), collectPageData(page, tree), {
+              tags: cacheTags.pages
+            })
+          )
+        )
+      ),
+      Effect.map((data) => metaOnly === true ? convertCombinedPageDataToMetaOnly(data) : data),
+      Effect.catchTag("KillSwitch", () => Effect.succeed(void 0))
+    );
+  }
+  function _getPageBySlug(slug, metaOnly = false) {
+    return _getPageBySlugFromDB(slug).pipe(
+      Effect.flatMap((page) => page ? Effect.succeed(page) : Effect.fail(new KillSwitch())),
+      Effect.flatMap(
+        (page) => GET.folderTree().pipe(
+          Effect.flatMap(
+            (tree) => memoize(cacheKeyGetters.page(page.id), collectPageData(page, tree), {
+              tags: cacheTags.pages
+            })
+          )
+        )
+      ),
+      Effect.map((data) => metaOnly === true ? convertCombinedPageDataToMetaOnly(data) : data),
+      Effect.catchTag("KillSwitch", () => Effect.succeed(void 0))
+    );
+  }
+  function _getPackagesPages(packageName, metaOnly = false) {
+    return _getPageByPackageFromDB(packageName).pipe(
+      Effect.flatMap((page) => page ? Effect.succeed(page) : Effect.fail(new KillSwitch())),
+      Effect.flatMap(
+        (page) => GET.folderTree().pipe(
+          Effect.flatMap(
+            (tree) => memoize(cacheKeyGetters.page(page.id), collectPageData(page, tree), {
+              tags: cacheTags.pages
+            })
+          )
+        )
+      ),
+      Effect.map((data) => metaOnly === true ? convertCombinedPageDataToMetaOnly(data) : data),
+      Effect.catchTag("KillSwitch", () => Effect.succeed([]))
+    );
+  }
+  function _folderPages(idOrName, includeDrafts = false, metaOnly = false, paginate) {
+    return _getFolderByNameOrId(idOrName).pipe(
+      Effect.flatMap(
+        ({ id: folderId }) => __getPagesPossiblyPaginated(paginate).pipe(
+          Effect.flatMap(
+            (pagesRaw) => __filterPagesByDraft(
+              pagesRaw.filter((page) => page.parentFolder === folderId),
+              includeDrafts
+            )
+          ),
+          Effect.flatMap(
+            (pages) => Effect.all({
+              pages: Effect.succeed(pages),
+              tree: GET.folderTree()
+            })
+          ),
+          Effect.flatMap(
+            ({ pages, tree }) => Effect.forEach(
+              pages,
+              (page) => memoize(cacheKeyGetters.page(page.id), collectPageData(page, tree), {
+                tags: cacheTags.pages
+              })
+            )
+          ),
+          Effect.map((data) => metaOnly ? convertCombinedPageDataToMetaOnly(data) : data)
+        )
+      )
+    );
+  }
+  const _pageFolderTree = (excludeDrafts = false) => Effect.gen(function* () {
+    const includeDrafts = !excludeDrafts;
+    const [tree, pages] = yield* Effect.all([GET.folderTree(), _getAllPages(includeDrafts)]);
+    for (const page of pages) {
+      if (page.parentFolder) {
+        yield* addPageToFolderTree(tree, page.parentFolder, {
+          id: page.id,
+          name: page.title,
+          page: true,
+          pageData: page,
+          children: []
+        });
+      } else {
+        tree.push({
+          id: page.id,
+          name: page.title,
+          page: true,
+          pageData: page,
+          children: []
+        });
+      }
+    }
+    return tree;
+  });
+  const getAllCategories = () => memoize(
+    cacheKeyGetters.categories(),
+    withDecoder({
+      decoder: Schema.Array(StudioCMSPageDataCategories.Select),
+      callbackFn: (db) => db((client) => client.selectFrom("StudioCMSPageDataCategories").selectAll().execute())
+    })(),
+    { tags: [...cacheTags.categories, ...cacheTags.taxonomy] }
+  );
+  const getCategoryById = Effect.fn(
+    (categoryId) => memoize(
+      cacheKeyGetters.categoryById(categoryId),
+      withCodec({
+        encoder: Schema.Number,
+        decoder: Schema.UndefinedOr(StudioCMSPageDataCategories.Select),
+        callbackFn: (db, categoryId2) => db(
+          (client) => client.selectFrom("StudioCMSPageDataCategories").selectAll().where("id", "=", categoryId2).executeTakeFirst()
+        )
+      })(categoryId),
+      { tags: [...cacheTags.categories, ...cacheTags.taxonomy] }
+    )
+  );
+  const getCategoryBySlug = Effect.fn(
+    (slug) => memoize(
+      cacheKeyGetters.categoryBySlug(slug),
+      withCodec({
+        encoder: Schema.String,
+        decoder: Schema.UndefinedOr(StudioCMSPageDataCategories.Select),
+        callbackFn: (db, slug2) => db(
+          (client) => client.selectFrom("StudioCMSPageDataCategories").selectAll().where("slug", "=", slug2).executeTakeFirst()
+        )
+      })(slug),
+      { tags: [...cacheTags.categories, ...cacheTags.taxonomy] }
+    )
+  );
+  const getAllTags = () => memoize(
+    cacheKeyGetters.tags(),
+    withDecoder({
+      decoder: Schema.Array(StudioCMSPageDataTags.Select),
+      callbackFn: (db) => db((client) => client.selectFrom("StudioCMSPageDataTags").selectAll().execute())
+    })(),
+    { tags: [...cacheTags.tags, ...cacheTags.taxonomy] }
+  );
+  const getTagById = Effect.fn(
+    (tagId) => memoize(
+      cacheKeyGetters.tagById(tagId),
+      withCodec({
+        encoder: Schema.Number,
+        decoder: Schema.UndefinedOr(StudioCMSPageDataTags.Select),
+        callbackFn: (db, tagId2) => db(
+          (client) => client.selectFrom("StudioCMSPageDataTags").selectAll().where("id", "=", tagId2).executeTakeFirst()
+        )
+      })(tagId),
+      { tags: [...cacheTags.tags, ...cacheTags.taxonomy] }
+    )
+  );
+  const getTagBySlug = Effect.fn(
+    (slug) => memoize(
+      cacheKeyGetters.tagBySlug(slug),
+      withCodec({
+        encoder: Schema.String,
+        decoder: Schema.UndefinedOr(StudioCMSPageDataTags.Select),
+        callbackFn: (db, slug2) => db(
+          (client) => client.selectFrom("StudioCMSPageDataTags").selectAll().where("slug", "=", slug2).executeTakeFirst()
+        )
+      })(slug),
+      { tags: [...cacheTags.tags, ...cacheTags.taxonomy] }
+    )
+  );
+  const GET = {
+    /**
+     * Lists of permissions categorized by user ranks.
+     */
+    permissionsLists: {
+      /**
+       * Retrieves all combined ranks with their corresponding users.
+       *
+       * @returns An array of combined rank records.
+       */
+      all: _getCombinedRanks,
+      // Dynamically generate functions for each rank (e.g., owners, admins, editors, visitors)
+      ...ranks.reduce((acc, rank) => {
+        acc[`${rank}s`] = () => _getPermissionsByRank(rank);
+        return acc;
+      }, {})
+    },
+    /**
+     * User-related GET operations.
+     */
+    users: {
+      /**
+       * Retrieves all users excluding the ghost user.
+       *
+       * @returns An array of user data records.
+       */
+      all: _getAllUsers,
+      /**
+       * Retrieves a user by their ID.
+       *
+       * @param userId - The ID of the user to fetch.
+       * @returns The user data record if found, otherwise undefined.
+       */
+      byId: _getUserByIdExposed,
+      /**
+       * Retrieves a user by their username.
+       *
+       * @param username - The username of the user to fetch.
+       * @returns The user data record if found, otherwise undefined.
+       */
+      byUsername: _getUserByUsernameExposed,
+      /**
+       * Retrieves a user by their email.
+       *
+       * @param email - The email of the user to fetch.
+       * @returns The user data record if found, otherwise undefined.
+       */
+      byEmail: _getUserByEmailExposed
+    },
+    /**
+     * Retrieves a folder by its ID.
+     *
+     * @param folderId - The ID of the folder to fetch.
+     * @returns The folder record if found, otherwise undefined.
+     */
+    folder: Effect.fn(
+      (folderId) => memoize(cacheKeyGetters.folder(folderId), _getFolder(folderId), {
+        tags: cacheTags.folder
+      })
+    ),
+    /**
+     * Retrieves the folder tree structure.
+     *
+     * @returns The folder tree structure.
+     */
+    folderTree: () => buildFolderTree,
+    /**
+     * Retrieves a list of folders.
+     *
+     * @returns An array of folder records.
+     */
+    folderList: () => memoize(cacheKeyGetters.folderList(), getAvailableFolders, {
+      tags: cacheTags.folderList
+    }),
+    /**
+     * Retrieves the site configuration.
+     *
+     * @returns The site configuration object.
+     */
+    siteConfig: sdkSiteConfig.get,
+    /**
+     * Retrieves the latest version of StudioCMS from NPM.
+     *
+     * @returns The latest version string.
+     */
+    latestVersion: () => getVersion("studiocms"),
+    /**
+     * Retrieves all pages.
+     *
+     * @returns An array of page data records.
+     */
+    pages: _getAllPages,
+    /**
+     * Utilities to get pages by specific criteria.
+     */
+    page: {
+      /**
+       * Retrieves a page by its ID.
+       *
+       * @param id - The ID of the page to fetch.
+       * @returns The page data record if found, otherwise undefined.
+       */
+      byId: _getPageById,
+      /**
+       * Retrieves a page by its slug.
+       *
+       * @param slug - The slug of the page to fetch.
+       * @returns The page data record if found, otherwise undefined.
+       */
+      bySlug: _getPageBySlug
+    },
+    /**
+     * Retrieves pages associated with a specific package.
+     *
+     * @param packageName - The name of the package to fetch pages for.
+     * @returns An array of page data records associated with the specified package.
+     */
+    packagePages: _getPackagesPages,
+    /**
+     * Retrieves pages within a specific folder.
+     *
+     * @param idOrName - The ID or name of the folder.
+     * @returns An array of page data records within the specified folder.
+     */
+    folderPages: _folderPages,
+    /**
+     * Retrieves the page folder tree structure.
+     *
+     * @returns The page folder tree structure.
+     */
+    pageFolderTree: _pageFolderTree,
+    /**
+     * Category-related GET operations.
+     */
+    categories: {
+      /**
+       * Retrieves all categories.
+       *
+       * @returns An array of category records.
+       */
+      getAll: getAllCategories,
+      /**
+       * Retrieves a category by its ID.
+       *
+       * @param categoryId - The ID of the category to fetch.
+       * @returns The category record if found, otherwise undefined.
+       */
+      byId: getCategoryById,
+      /**
+       * Retrieves a category by its slug.
+       *
+       * @param slug - The slug of the category to fetch.
+       * @returns The category record if found, otherwise undefined.
+       */
+      bySlug: getCategoryBySlug
+    },
+    /**
+     * Tag-related GET operations.
+     */
+    tags: {
+      /**
+       * Retrieves all tags.
+       *
+       * @returns An array of tag records.
+       */
+      getAll: getAllTags,
+      /**
+       * Retrieves a tag by its ID.
+       *
+       * @param tagId - The ID of the tag to fetch.
+       * @returns The tag record if found, otherwise undefined.
+       */
+      byId: getTagById,
+      /**
+       * Retrieves a tag by its slug.
+       *
+       * @param slug - The slug of the tag to fetch.
+       * @returns The tag record if found, otherwise undefined.
+       */
+      bySlug: getTagBySlug
+    }
+  };
+  return GET;
+});
+var get_default = SDKGetModule;
+export {
+  KillSwitch,
+  PaginateError,
+  SDKGetModule,
+  get_default as default
+};