studiocms 0.1.0-beta.10

package/dist/sdk/tables.js

@@ -0,0 +1,55 @@
+import { asDrizzleTable } from "@astrojs/db/utils";
+import {
+  StudioCMSAPIKeys,
+  StudioCMSDiffTracking,
+  StudioCMSOAuthAccounts,
+  StudioCMSPageContent,
+  StudioCMSPageData,
+  StudioCMSPageDataCategories,
+  StudioCMSPageDataTags,
+  StudioCMSPageFolderStructure,
+  StudioCMSPermissions,
+  StudioCMSSessionTable,
+  StudioCMSSiteConfig,
+  StudioCMSUserResetTokens,
+  StudioCMSUsers
+} from "../db/tables.js";
+import { tsMetric } from "../lib/webVitals/consts.js";
+const tsAPIKeys = asDrizzleTable("StudioCMSAPIKeys", StudioCMSAPIKeys);
+const tsPageContent = asDrizzleTable("StudioCMSPageContent", StudioCMSPageContent);
+const tsPageData = asDrizzleTable("StudioCMSPageData", StudioCMSPageData);
+const tsPageDataCategories = asDrizzleTable(
+  "StudioCMSPageDataCategories",
+  StudioCMSPageDataCategories
+);
+const tsPageDataTags = asDrizzleTable("StudioCMSPageDataTags", StudioCMSPageDataTags);
+const tsPermissions = asDrizzleTable("StudioCMSPermissions", StudioCMSPermissions);
+const tsSessionTable = asDrizzleTable("StudioCMSSessionTable", StudioCMSSessionTable);
+const tsSiteConfig = asDrizzleTable("StudioCMSSiteConfig", StudioCMSSiteConfig);
+const tsUsers = asDrizzleTable("StudioCMSUsers", StudioCMSUsers);
+const tsOAuthAccounts = asDrizzleTable("StudioCMSOAuthAccounts", StudioCMSOAuthAccounts);
+const tsDiffTracking = asDrizzleTable("StudioCMSDiffTracking", StudioCMSDiffTracking);
+const tsPageFolderStructure = asDrizzleTable(
+  "StudioCMSPageFolderStructure",
+  StudioCMSPageFolderStructure
+);
+const tsUserResetTokens = asDrizzleTable(
+  "StudioCMSUserResetTokens",
+  StudioCMSUserResetTokens
+);
+export {
+  tsAPIKeys,
+  tsDiffTracking,
+  tsMetric,
+  tsOAuthAccounts,
+  tsPageContent,
+  tsPageData,
+  tsPageDataCategories,
+  tsPageDataTags,
+  tsPageFolderStructure,
+  tsPermissions,
+  tsSessionTable,
+  tsSiteConfig,
+  tsUserResetTokens,
+  tsUsers
+};

package/dist/sdk/types/index.d.ts

@@ -0,0 +1,175 @@
+import type { CacheConfig, ProcessedCacheConfig, ProcessedSDKConfig } from '../../schemas/config/sdk.js';
+import type StudioCMSVirtualCache from '../StudioCMSVirtualCache.js';
+import type { AvailableLists, CombinedRank, DatabaseTables, PageContentReturnId, PageDataCategoriesInsertResponse, PageDataReturnId, PageDataStripped, PageDataTagsInsertResponse, SingleRank, SiteConfig } from './tableDefs.js';
+import type { CombinedInsertContent, tsDiffTrackingInsert, tsDiffTrackingSelect, tsOAuthAccountsSelect, tsPageContentInsert, tsPageContentSelect, tsPageDataCategoriesInsert, tsPageDataCategoriesSelect, tsPageDataInsert, tsPageDataSelect, tsPageDataTagsInsert, tsPageDataTagsSelect, tsPageFolderInsert, tsPageFolderSelect, tsPermissionsInsert, tsPermissionsSelect, tsSessionTableInsert, tsSessionTableSelect, tsSiteConfigInsert, tsSiteConfigSelect, tsUsersInsert, tsUsersSelect, tsUsersUpdate } from './tsAlias.js';
+export type { AvailableLists, CombinedRank, DatabaseTables, PageContentReturnId, PageDataCategoriesInsertResponse, PageDataReturnId, PageDataStripped, PageDataTagsInsertResponse, SingleRank, SiteConfig, };
+export type { tsDiffTrackingInsert, tsDiffTrackingSelect, CombinedInsertContent, tsOAuthAccountsSelect, tsPageContentInsert, tsPageContentSelect, tsPageDataCategoriesInsert, tsPageDataCategoriesSelect, tsPageDataInsert, tsPageDataSelect, tsPageDataTagsInsert, tsPageDataTagsSelect, tsPermissionsSelect, tsPermissionsInsert, tsSiteConfigInsert, tsSessionTableSelect, tsSiteConfigSelect, tsUsersSelect, tsUsersInsert, tsSessionTableInsert, tsUsersUpdate, tsPageFolderInsert, tsPageFolderSelect, };
+export interface FolderNode {
+    id: string;
+    name: string;
+    page: boolean;
+    pageData: CombinedPageData | null;
+    children: FolderNode[];
+}
+export interface FolderListItem {
+    id: string;
+    name: string;
+    parent?: string | null;
+}
+export type AstroDBVirtualModule = typeof import('astro:db');
+export type { CacheConfig, ProcessedCacheConfig, ProcessedSDKConfig };
+/**
+ * Type definition for the constructor of the StudioCMS SDK Cache.
+ *
+ * This type represents the constructor function of the `StudioCMSVirtualCache` class.
+ */
+export type STUDIOCMS_SDK_CACHEConstructor = typeof StudioCMSVirtualCache;
+/**
+ * Type representing an instance of the STUDIOCMS SDK cache.
+ *
+ * This type is derived from the constructor type `STUDIOCMS_SDK_CACHEConstructor`.
+ * It is used to define the shape of the cache instance within the STUDIOCMS SDK.
+ */
+export type STUDIOCMS_SDK_CACHEInstance = InstanceType<STUDIOCMS_SDK_CACHEConstructor>;
+/**
+ * Type representing the return type of the `STUDIOCMS_SDK_CACHEModule` function.
+ */
+export type STUDIOCMS_SDK_CACHE = STUDIOCMS_SDK_CACHEInstance['cacheModule'];
+/**
+ * Represents a base cache object with a timestamp of the last cache update.
+ */
+export interface BaseCacheObject {
+    lastCacheUpdate: Date;
+}
+/**
+ * Represents a cache object for page data.
+ * Extends the BaseCacheObject interface.
+ *
+ * @interface PageDataCacheObject
+ * @extends {BaseCacheObject}
+ *
+ * @property {CombinedPageData} data - The combined page data to be cached.
+ */
+export interface PageDataCacheObject extends BaseCacheObject {
+    data: CombinedPageData;
+}
+/**
+ * Represents a cache object for site configuration.
+ * Extends the BaseCacheObject interface.
+ *
+ * @interface SiteConfigCacheObject
+ * @extends {BaseCacheObject}
+ *
+ * @property {SiteConfig} data - The site configuration data.
+ */
+export interface SiteConfigCacheObject extends BaseCacheObject {
+    data: SiteConfig;
+}
+/**
+ * Represents a cache object that includes version information.
+ *
+ * @extends BaseCacheObject
+ *
+ * @property {string} version - The version of the cache object.
+ */
+export interface VersionCacheObject extends BaseCacheObject {
+    version: string;
+}
+/**
+ * Represents a cache object for folder tree data.
+ * Extends the BaseCacheObject interface.
+ *
+ * @interface FolderTreeCacheObject
+ * @extends {BaseCacheObject}
+ *
+ * @property {FolderNode[]} data - The folder tree data to be cached.
+ */
+export interface FolderTreeCacheObject extends BaseCacheObject {
+    data: FolderNode[];
+}
+/**
+ * Represents a cache object for folder list data.
+ * Extends the BaseCacheObject interface.
+ *
+ * @interface FolderListCacheObject
+ * @extends {BaseCacheObject}
+ *
+ * @property {FolderListItem[]} data - The folder list data to be cached.
+ */
+export interface FolderListCacheObject extends BaseCacheObject {
+    data: FolderListItem[];
+}
+/**
+ * Represents a cache object that stores pages and site configuration data.
+ */
+export interface StudioCMSCacheObject {
+    pages: Map<string, PageDataCacheObject>;
+    siteConfig: SiteConfigCacheObject | undefined;
+    version: VersionCacheObject | undefined;
+}
+/**
+ * Represents the structure for adding a database entry for a page.
+ *
+ * @property {PageDataReturnId[]} pageData - An array of page data objects with return IDs.
+ * @property {PageContentReturnId[]} pageContent - An array of page content objects with return IDs.
+ */
+export type addDatabaseEntryInsertPage = {
+    pageData: PageDataReturnId[];
+    pageContent: PageContentReturnId[];
+};
+/**
+ * Interface representing combined user data.
+ *
+ * This interface extends `tsUsersSelect` and includes additional properties
+ * for OAuth data and permissions data.
+ *
+ * @interface CombinedUserData
+ * @extends {tsUsersSelect}
+ *
+ * @property {tsOAuthAccountsSelect[] | undefined} oAuthData - An array of OAuth account data or undefined.
+ * @property {tsPermissionsSelect | undefined} permissionsData - Permissions data or undefined.
+ */
+export interface CombinedUserData extends tsUsersSelect {
+    oAuthData: tsOAuthAccountsSelect[] | undefined;
+    permissionsData: tsPermissionsSelect | undefined;
+}
+/**
+ * Represents the combined data for a page, extending the stripped page data.
+ *
+ * @interface CombinedPageData
+ * @extends PageDataStripped
+ *
+ * @property {string[]} contributorIds - An array of contributor IDs associated with the page.
+ * @property {tsPageDataCategoriesSelect[]} categories - An array of categories selected for the page.
+ * @property {tsPageDataTagsSelect[]} tags - An array of tags selected for the page.
+ * @property {tsPageContentSelect[]} content - An array of content selected for the page.
+ */
+export interface CombinedPageData extends PageDataStripped {
+    contributorIds: string[];
+    categories: tsPageDataCategoriesSelect[];
+    tags: tsPageDataTagsSelect[];
+    multiLangContent: tsPageContentSelect[];
+    defaultContent: tsPageContentSelect | undefined;
+    urlRoute: string;
+}
+/**
+ * Interface representing the response received after a deletion operation.
+ *
+ * @property {string} status - The status of the deletion operation.
+ * @property {string} message - A message providing additional information about the deletion operation.
+ */
+export interface DeletionResponse {
+    status: 'success' | 'error';
+    message: string;
+}
+/**
+ * Represents the data required to insert a new page.
+ */
+export interface PageInsert {
+    pageData: tsPageDataInsert;
+    pageContent: CombinedInsertContent;
+}
+/**
+ * Represents an array of PageInsert objects.
+ */
+export type MultiPageInsert = PageInsert[];

package/dist/sdk/types/tableDefs.d.ts

@@ -0,0 +1,75 @@
+import type { tsDiffTrackingSelect, tsOAuthAccountsSelect, tsPageContentSelect, tsPageDataCategoriesSelect, tsPageDataSelect, tsPageDataTagsSelect, tsPermissionsSelect, tsSessionTableSelect, tsSiteConfigSelect, tsUsersSelect } from './tsAlias.js';
+/**
+ * Represents a stripped-down version of the `tsSiteConfigSelect` type,
+ * excluding the property 'id'.
+ */
+export type SiteConfig = Omit<tsSiteConfigSelect, 'id'>;
+/**
+ * Represents a stripped-down version of the `tsPageDataSelect` type,
+ * excluding the properties 'categories', 'tags', and 'contributorIds'.
+ */
+export type PageDataStripped = Omit<tsPageDataSelect, 'categories' | 'tags' | 'contributorIds'>;
+/**
+ * Represents a type that picks the 'id' property from the tsPageContentSelect type.
+ */
+export type PageDataReturnId = Pick<tsPageContentSelect, 'id'>;
+/**
+ * Represents a type that picks the 'id' property from the tsPageDataSelect type.
+ * This type is used to return only the 'id' field from a tsPageDataSelect object.
+ */
+export type PageContentReturnId = Pick<tsPageDataSelect, 'id'>;
+/**
+ * Represents the response type for inserting page data tags.
+ * This type is a subset of `tsPageDataTagsSelect` containing only the `id` field.
+ */
+export type PageDataTagsInsertResponse = Pick<tsPageDataTagsSelect, 'id'>;
+/**
+ * Represents the response type for inserting a new page data category.
+ * This type is a subset of `tsPageDataCategoriesSelect` containing only the 'id' field.
+ */
+export type PageDataCategoriesInsertResponse = Pick<tsPageDataCategoriesSelect, 'id'>;
+/**
+ * Represents the possible types of database tables used in the application.
+ *
+ * This type is a union of several specific table selection types, each representing
+ * a different table in the database. The possible types include:
+ * - `tsUsersSelect[]`: An array of user selection objects.
+ * - `tsOAuthAccountsSelect[]`: An array of OAuth account selection objects.
+ * - `tsSessionTableSelect[]`: An array of session table selection objects.
+ * - `tsPermissionsSelect[]`: An array of permission selection objects.
+ * - `tsSiteConfigSelect`: A site configuration selection object.
+ * - `tsPageDataSelect[]`: An array of page data selection objects.
+ * - `tsPageDataTagsSelect[]`: An array of page data tags selection objects.
+ * - `tsPageDataCategoriesSelect[]`: An array of page data categories selection objects.
+ * - `tsPageContentSelect[]`: An array of page content selection objects.
+ * - `tsDiffTrackingSelect[]`: An array of diff tracking selection objects.
+ * - `undefined`: Represents an undefined state.
+ */
+export type DatabaseTables = tsUsersSelect[] | tsOAuthAccountsSelect[] | tsSessionTableSelect[] | tsPermissionsSelect[] | tsSiteConfigSelect | tsPageDataSelect[] | tsPageDataTagsSelect[] | tsPageDataCategoriesSelect[] | tsPageContentSelect[] | tsDiffTrackingSelect[] | undefined;
+/**
+ * Represents a single rank with an identifier and a name.
+ */
+export interface SingleRank {
+    id: string;
+    name: string;
+}
+/**
+ * Represents a combined rank with associated details.
+ *
+ * @property {string} rank - The rank of the entity.
+ * @property {string} id - The unique identifier for the rank.
+ * @property {string} name - The name associated with the rank.
+ */
+export interface CombinedRank extends SingleRank {
+    rank: string;
+}
+/**
+ * Represents the different types of user lists available in the system.
+ *
+ * - 'owners': List of owners.
+ * - 'admins': List of administrators.
+ * - 'editors': List of editors.
+ * - 'visitors': List of visitors.
+ * - 'all': List of all users.
+ */
+export type AvailableLists = 'owners' | 'admins' | 'editors' | 'visitors' | 'all';

package/dist/sdk/types/tsAlias.d.ts

@@ -0,0 +1,155 @@
+import type { tsDiffTracking, tsOAuthAccounts, tsPageContent, tsPageData, tsPageDataCategories, tsPageDataTags, tsPageFolderStructure, tsPermissions, tsSessionTable, tsSiteConfig, tsUsers } from '../tables.js';
+/**
+ * Type alias for the inferred select type of `tsPageFolderStructure`.
+ *
+ * This type is derived from the `$inferSelect` property of `tsPageFolderStructure`.
+ * It represents the structure of data that can be selected from the folder structure.
+ */
+export type tsPageFolderSelect = typeof tsPageFolderStructure.$inferSelect;
+/**
+ * Type alias for the inferred insert type of `tsPageFolderStructure`.
+ *
+ * This type is derived from the `$inferInsert` property of `tsPageFolderStructure`.
+ * It represents the structure of data that can be inserted into the folder structure.
+ */
+export type tsPageFolderInsert = typeof tsPageFolderStructure.$inferInsert;
+/**
+ * Type alias for the inferred select type of `tsUsers`.
+ *
+ * This type is derived from the `$inferSelect` property of `tsUsers`.
+ * It represents the shape of the data that will be selected from the `tsUsers` object.
+ */
+export type tsUsersSelect = typeof tsUsers.$inferSelect;
+/**
+ * Type alias for inserting users.
+ *
+ * This type is inferred from the `tsUsers` object, specifically its `$inferInsert` property.
+ * It represents the structure of data required to insert a new user into the system.
+ */
+export type tsUsersInsert = typeof tsUsers.$inferInsert;
+/**
+ * Represents a type for updating users, where all properties are optional.
+ * This type is a partial version of the `tsUsersInsert` type.
+ */
+export type tsUsersUpdate = Partial<tsUsersInsert>;
+/**
+ * Type alias for the inferred select type of the `tsOAuthAccounts` object.
+ *
+ * This type is derived from the `$inferSelect` property of the `tsOAuthAccounts` object,
+ * which is used to infer the shape of the selected data from the OAuth accounts.
+ */
+export type tsOAuthAccountsSelect = typeof tsOAuthAccounts.$inferSelect;
+/**
+ * Type alias for the inferred select type of the `tsSessionTable`.
+ *
+ * This type is derived from the `$inferSelect` property of the `tsSessionTable` object,
+ * which represents the structure of a selected row from the `tsSessionTable`.
+ */
+export type tsSessionTableSelect = typeof tsSessionTable.$inferSelect;
+/**
+ * Type alias for the inferred insert type of the `tsSessionTable`.
+ *
+ * This type is derived from the `$inferInsert` property of the `tsSessionTable` object,
+ * which represents the structure of data that can be inserted into the session table.
+ */
+export type tsSessionTableInsert = typeof tsSessionTable.$inferInsert;
+/**
+ * Type alias for the inferred select type of `tsPermissions`.
+ *
+ * This type is derived from the `$inferSelect` property of `tsPermissions`.
+ * It is used to represent the shape of the data that can be selected from `tsPermissions`.
+ */
+export type tsPermissionsSelect = typeof tsPermissions.$inferSelect;
+/**
+ * Type alias for inserting permissions.
+ *
+ * This type is inferred from the `tsPermissions` object, specifically its `$inferInsert` property.
+ * It represents the structure of data required to insert new permissions.
+ */
+export type tsPermissionsInsert = typeof tsPermissions.$inferInsert;
+/**
+ * Type alias for the inferred select type of `tsPageData`.
+ *
+ * This type is derived from the `$inferSelect` property of `tsPageData`.
+ */
+export type tsPageDataSelect = typeof tsPageData.$inferSelect;
+/**
+ * Type representing the selection of tags from the `tsPageDataTags` object.
+ *
+ * This type is inferred from the `$inferSelect` property of the `tsPageDataTags` object.
+ */
+export type tsPageDataTagsSelect = typeof tsPageDataTags.$inferSelect;
+/**
+ * Type representing the selection of page data categories.
+ *
+ * This type is inferred from the `tsPageDataCategories` object using the `$inferSelect` property.
+ */
+export type tsPageDataCategoriesSelect = typeof tsPageDataCategories.$inferSelect;
+/**
+ * Type alias for the inferred select type of `tsDiffTracking`.
+ *
+ * This type is derived from the `$inferSelect` property of `tsDiffTracking`.
+ */
+export type tsDiffTrackingSelect = typeof tsDiffTracking.$inferSelect;
+/**
+ * Type alias for the inferred Insert type of `tsDiffTracking`.
+ *
+ * This type is derived from the `$inferInsert` property of `tsDiffTracking`.
+ */
+export type tsDiffTrackingInsert = typeof tsDiffTracking.$inferInsert;
+/**
+ * Type alias for the inferred select type of `tsPageContent`.
+ *
+ * This type is derived from the `$inferSelect` property of `tsPageContent`.
+ * It is used to represent the structure of the selected content from `tsPageContent`.
+ */
+export type tsPageContentSelect = typeof tsPageContent.$inferSelect;
+/**
+ * Type representing the selection of site configuration data.
+ *
+ * This type is inferred from the `$inferSelect` property of the `tsSiteConfig` object.
+ */
+export type tsSiteConfigSelect = typeof tsSiteConfig.$inferSelect;
+/**
+ * Type representing the insertion of site configuration data.
+ *
+ * This type is inferred from the `$inferInsert` property of the `tsSiteConfig` object.
+ */
+export type tsSiteConfigInsert = typeof tsSiteConfig.$inferInsert;
+/**
+ * Type alias for the inferred insert type of `tsPageData`.
+ *
+ * This type is derived from the `$inferInsert` property of `tsPageData`.
+ * It represents the shape of data that can be inserted into the `tsPageData` structure.
+ */
+export type tsPageDataInsert = typeof tsPageData.$inferInsert;
+/**
+ * Type alias for the inferred insert type of `tsPageContent`.
+ *
+ * This type is derived from the `$inferInsert` property of `tsPageContent`.
+ * It represents the structure of data that can be inserted into the `tsPageContent`.
+ */
+export type tsPageContentInsert = typeof tsPageContent.$inferInsert;
+/**
+ * Represents a type that combines the properties of `tsPageContentInsert`
+ * excluding 'id' and 'contentId'.
+ *
+ * This type is useful when you need to insert content without specifying
+ * the 'id' and 'contentId' fields, which might be auto-generated or
+ * handled separately.
+ */
+export type CombinedInsertContent = Omit<tsPageContentInsert, 'id' | 'contentId'>;
+/**
+ * Type alias for the inferred insert type of `tsPageDataTags`.
+ *
+ * This type is derived from the `$inferInsert` property of `tsPageDataTags`.
+ * It represents the shape of data that can be inserted into the `tsPageDataTags` table.
+ */
+export type tsPageDataTagsInsert = typeof tsPageDataTags.$inferInsert;
+/**
+ * Type alias for the inferred insert type of `tsPageDataCategories`.
+ *
+ * This type is derived from the `$inferInsert` property of `tsPageDataCategories`.
+ * It represents the structure of data that can be inserted into the `tsPageDataCategories` table.
+ */
+export type tsPageDataCategoriesInsert = typeof tsPageDataCategories.$inferInsert;

package/dist/sdk/utils/db.d.ts

@@ -0,0 +1,5 @@
+import * as schema from '../tables.js';
+/**
+ * Returns a new Drizzle libSQL connection.
+ */
+export declare const useDB: () => import("drizzle-orm/libsql").LibSQLDatabase<typeof schema>;

package/dist/sdk/utils/db.js

@@ -0,0 +1,15 @@
+import { dbSecret, dbUrl } from "virtual:studiocms/sdk/env";
+import { createClient } from "@libsql/client/web";
+import { drizzle } from "drizzle-orm/libsql";
+import * as schema from "../tables.js";
+const useDB = () => {
+  const client = createClient({
+    url: dbUrl,
+    authToken: dbSecret
+  });
+  const db = drizzle(client, { schema });
+  return db;
+};
+export {
+  useDB
+};

package/dist/stubs/auth-lib.d.ts

@@ -0,0 +1,2 @@
+declare const dtsFile: import("@matthiesenxyz/astrodtsbuilder").InjectedType;
+export default dtsFile;