@studiocms/migrator 0.0.0-beta.0 → 0.1.0

package/src/lib/remapUtils.ts

@@ -0,0 +1,170 @@
+import type { AstroDBTableKeys, GetMigrationTypes } from './tableMap.js';
+
+type Users = GetMigrationTypes<'StudioCMSUsers'>;
+type PageData = GetMigrationTypes<'StudioCMSPageData'>;
+type PageFolders = GetMigrationTypes<'StudioCMSPageFolderStructure'>;
+type PageDataTags = GetMigrationTypes<'StudioCMSPageDataTags'>;
+type PageDataCategories = GetMigrationTypes<'StudioCMSPageDataCategories'>;
+type PluginData = GetMigrationTypes<'StudioCMSPluginData'>;
+type DynamicConfig = GetMigrationTypes<'StudioCMSDynamicConfigSettings'>;
+type apiKeys = GetMigrationTypes<'StudioCMSAPIKeys'>;
+type diffTracking = GetMigrationTypes<'StudioCMSDiffTracking'>;
+type emailVerificationTokens = GetMigrationTypes<'StudioCMSEmailVerificationTokens'>;
+type oAuthAccounts = GetMigrationTypes<'StudioCMSOAuthAccounts'>;
+type pageContent = GetMigrationTypes<'StudioCMSPageContent'>;
+type permissions = GetMigrationTypes<'StudioCMSPermissions'>;
+type sessionTable = GetMigrationTypes<'StudioCMSSessionTable'>;
+type userResetTokens = GetMigrationTypes<'StudioCMSUserResetTokens'>;
+
+const booleanToNumber = (value: boolean): number => (value ? 1 : 0);
+
+export const remapUsersTable = (astro: Users['astro'][]): Users['kysely'][] => {
+	return astro.map((user) => ({
+		...user,
+		// Add any necessary transformations here
+		createdAt: user.createdAt?.toISOString(),
+		updatedAt: new Date().toISOString(),
+		emailVerified: booleanToNumber(user.emailVerified),
+	}));
+};
+
+export const remapPageDataTable = (astro: PageData['astro'][]): PageData['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		// Add any necessary transformations here
+		updatedAt: new Date().toISOString(),
+		showOnNav: booleanToNumber(item.showOnNav),
+		showAuthor: booleanToNumber(item.showAuthor ?? false),
+		showContributors: booleanToNumber(item.showContributors ?? false),
+		publishedAt: item.publishedAt?.toISOString(),
+		categories: JSON.stringify(item.categories),
+		tags: JSON.stringify(item.tags),
+		contributorIds: JSON.stringify(item.contributorIds),
+		augments: JSON.stringify([]),
+		authorId: item.authorId ?? '',
+		draft: booleanToNumber(item.draft ?? false),
+	}));
+};
+
+export const remapPageFoldersTable = (astro: PageFolders['astro'][]): PageFolders['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+	}));
+};
+
+export const remapPageDataTagsTable = (
+	astro: PageDataTags['astro'][]
+): PageDataTags['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		meta: JSON.stringify(item.meta),
+	}));
+};
+
+export const remapPageDataCategoriesTable = (
+	astro: PageDataCategories['astro'][]
+): PageDataCategories['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		meta: JSON.stringify(item.meta),
+	}));
+};
+
+export const remapPluginDataTable = (astro: PluginData['astro'][]): PluginData['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		data: JSON.stringify(item.data),
+	}));
+};
+
+export const remapDynamicConfigTable = (
+	astro: DynamicConfig['astro'][]
+): DynamicConfig['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		data: JSON.stringify(item.data),
+	}));
+};
+
+export const remapApiKeysTable = (astro: apiKeys['astro'][]): apiKeys['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		creationDate: item.creationDate?.toISOString(),
+	}));
+};
+
+export const remapDiffTrackingTable = (
+	astro: diffTracking['astro'][]
+): diffTracking['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		pageMetaData: JSON.stringify(item.pageMetaData),
+		timestamp: item.timestamp?.toISOString(),
+	}));
+};
+
+export const remapEmailVerificationTokensTable = (
+	astro: emailVerificationTokens['astro'][]
+): emailVerificationTokens['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		expiresAt: item.expiresAt?.toISOString(),
+	}));
+};
+
+export const remapOAuthAccountsTable = (
+	astro: oAuthAccounts['astro'][]
+): oAuthAccounts['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+	}));
+};
+
+export const remapPageContentTable = (astro: pageContent['astro'][]): pageContent['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		content: item.content ?? '',
+	}));
+};
+
+export const remapPermissionsTable = (astro: permissions['astro'][]): permissions['kysely'][] => {
+	return astro.map(({ rank, user }) => ({
+		rank,
+		user,
+	}));
+};
+
+export const remapSessionTable = (astro: sessionTable['astro'][]): sessionTable['kysely'][] => {
+	return astro.map((item) => ({
+		...item,
+		expiresAt: item.expiresAt?.toISOString(),
+	}));
+};
+
+export const remapUserResetTokensTable = (
+	astro: userResetTokens['astro'][]
+): userResetTokens['kysely'][] => {
+	return astro;
+};
+
+export const remapFunctions: {
+	[key in AstroDBTableKeys]: (
+		astro: GetMigrationTypes<key>['astro'][]
+	) => GetMigrationTypes<key>['kysely'][];
+} = {
+	StudioCMSUsers: remapUsersTable,
+	StudioCMSPageData: remapPageDataTable,
+	StudioCMSPageFolderStructure: remapPageFoldersTable,
+	StudioCMSPageDataTags: remapPageDataTagsTable,
+	StudioCMSPageDataCategories: remapPageDataCategoriesTable,
+	StudioCMSPluginData: remapPluginDataTable,
+	StudioCMSDynamicConfigSettings: remapDynamicConfigTable,
+	StudioCMSAPIKeys: remapApiKeysTable,
+	StudioCMSDiffTracking: remapDiffTrackingTable,
+	StudioCMSEmailVerificationTokens: remapEmailVerificationTokensTable,
+	StudioCMSOAuthAccounts: remapOAuthAccountsTable,
+	StudioCMSPageContent: remapPageContentTable,
+	StudioCMSPermissions: remapPermissionsTable,
+	StudioCMSSessionTable: remapSessionTable,
+	StudioCMSUserResetTokens: remapUserResetTokensTable,
+};

package/src/lib/response-utils.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates a JSON Response with the given data and status code.
+ * @param data - The data to be included in the response body.
+ * @param status - The HTTP status code (default is 200).
+ * @returns A Response object with JSON content.
+ */
+export const jsonResponse = (data: unknown, status = 200) => {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: { 'Content-Type': 'application/json' },
+	});
+};

package/src/lib/tableMap.ts

@@ -0,0 +1,236 @@
+import type { Insertable } from '@withstudiocms/kysely/kysely';
+import {
+	StudioCMSAPIKeys as KyselyStudioCMSAPIKeys,
+	StudioCMSDiffTracking as KyselyStudioCMSDiffTracking,
+	StudioCMSDynamicConfigSettings as KyselyStudioCMSDynamicConfigSettings,
+	StudioCMSEmailVerificationTokens as KyselyStudioCMSEmailVerificationTokens,
+	StudioCMSOAuthAccounts as KyselyStudioCMSOAuthAccounts,
+	StudioCMSPageContent as KyselyStudioCMSPageContent,
+	StudioCMSPageData as KyselyStudioCMSPageData,
+	StudioCMSPageDataCategories as KyselyStudioCMSPageDataCategories,
+	StudioCMSPageDataTags as KyselyStudioCMSPageDataTags,
+	StudioCMSPageFolderStructure as KyselyStudioCMSPageFolderStructure,
+	StudioCMSPermissions as KyselyStudioCMSPermissions,
+	StudioCMSPluginData as KyselyStudioCMSPluginData,
+	StudioCMSSessionTable as KyselyStudioCMSSessionTable,
+	StudioCMSUserResetTokens as KyselyStudioCMSUserResetTokens,
+	StudioCMSUsersTable as KyselyStudioCMSUsersTable,
+} from '@withstudiocms/sdk/tables';
+import {
+	StudioCMSAPIKeys,
+	StudioCMSDiffTracking,
+	StudioCMSDynamicConfigSettings,
+	StudioCMSEmailVerificationTokens,
+	StudioCMSOAuthAccounts,
+	StudioCMSPageContent,
+	StudioCMSPageData,
+	StudioCMSPageDataCategories,
+	StudioCMSPageDataTags,
+	StudioCMSPageFolderStructure,
+	StudioCMSPermissions,
+	StudioCMSPluginData,
+	StudioCMSSessionTable,
+	StudioCMSUserResetTokens,
+	StudioCMSUsers,
+} from '../db/astro-db-drizzle-client.js';
+import { getDataMigrationMeta as getAstroDataMigrationMeta } from '../db/astrodb.js';
+import { getDataMigrationMeta as getKyselyDataMigrationMeta } from '../db/client.js';
+
+/**
+ * Schema definitions for AstroDB
+ */
+export const AstroDBTableSchema = {
+	StudioCMSAPIKeys,
+	StudioCMSDiffTracking,
+	StudioCMSDynamicConfigSettings,
+	StudioCMSEmailVerificationTokens,
+	StudioCMSOAuthAccounts,
+	StudioCMSPageContent,
+	StudioCMSPageData,
+	StudioCMSPageDataCategories,
+	StudioCMSPageDataTags,
+	StudioCMSPageFolderStructure,
+	StudioCMSPermissions,
+	StudioCMSPluginData,
+	StudioCMSSessionTable,
+	StudioCMSUserResetTokens,
+	StudioCMSUsers,
+};
+
+/**
+ * Schema definitions for Kysely
+ */
+export const KyselyTableSchema = {
+	StudioCMSAPIKeys: KyselyStudioCMSAPIKeys,
+	StudioCMSDiffTracking: KyselyStudioCMSDiffTracking,
+	StudioCMSDynamicConfigSettings: KyselyStudioCMSDynamicConfigSettings,
+	StudioCMSEmailVerificationTokens: KyselyStudioCMSEmailVerificationTokens,
+	StudioCMSOAuthAccounts: KyselyStudioCMSOAuthAccounts,
+	StudioCMSPageContent: KyselyStudioCMSPageContent,
+	StudioCMSPageData: KyselyStudioCMSPageData,
+	StudioCMSPageDataCategories: KyselyStudioCMSPageDataCategories,
+	StudioCMSPageDataTags: KyselyStudioCMSPageDataTags,
+	StudioCMSPageFolderStructure: KyselyStudioCMSPageFolderStructure,
+	StudioCMSPermissions: KyselyStudioCMSPermissions,
+	StudioCMSPluginData: KyselyStudioCMSPluginData,
+	StudioCMSSessionTable: KyselyStudioCMSSessionTable,
+	StudioCMSUserResetTokens: KyselyStudioCMSUserResetTokens,
+	StudioCMSUsersTable: KyselyStudioCMSUsersTable,
+};
+
+// Get table keys
+
+/**
+ * Array of AstroDB table keys.
+ */
+export const astroDbTableKeys = Object.keys(AstroDBTableSchema) as Array<
+	keyof typeof AstroDBTableSchema
+>;
+
+/**
+ * Array of AstroDB table keys that have no references to other tables.
+ */
+export const tablesWithNoReferences = [
+	'StudioCMSUsers',
+	'StudioCMSPageData',
+	'StudioCMSPageFolderStructure',
+	'StudioCMSPageDataTags',
+	'StudioCMSPageDataCategories',
+	'StudioCMSPluginData',
+	'StudioCMSDynamicConfigSettings',
+] as const;
+
+/**
+ * Array of AstroDB table keys that have references to other tables.
+ */
+export const tablesWithReferences: Exclude<
+	AstroDBTableKeys,
+	(typeof tablesWithNoReferences)[number]
+>[] = [
+	'StudioCMSAPIKeys',
+	'StudioCMSDiffTracking',
+	'StudioCMSEmailVerificationTokens',
+	'StudioCMSOAuthAccounts',
+	'StudioCMSPageContent',
+	'StudioCMSPermissions',
+	'StudioCMSSessionTable',
+	'StudioCMSUserResetTokens',
+];
+
+/**
+ * Array of Kysely table keys.
+ */
+export const kyselyTableKeys = Object.keys(KyselyTableSchema) as Array<
+	keyof typeof KyselyTableSchema
+>;
+
+// Define table key types
+export type AstroDBTableKeys = (typeof astroDbTableKeys)[number];
+export type KyselyTableKeys = (typeof kyselyTableKeys)[number];
+
+/**
+ * Mapping from AstroDB table names to Kysely table names for StudioCMS.
+ */
+export const astroDBToKyselyMap = {
+	StudioCMSAPIKeys: 'StudioCMSAPIKeys',
+	StudioCMSDiffTracking: 'StudioCMSDiffTracking',
+	StudioCMSDynamicConfigSettings: 'StudioCMSDynamicConfigSettings',
+	StudioCMSEmailVerificationTokens: 'StudioCMSEmailVerificationTokens',
+	StudioCMSOAuthAccounts: 'StudioCMSOAuthAccounts',
+	StudioCMSPageContent: 'StudioCMSPageContent',
+	StudioCMSPageData: 'StudioCMSPageData',
+	StudioCMSPageDataCategories: 'StudioCMSPageDataCategories',
+	StudioCMSPageDataTags: 'StudioCMSPageDataTags',
+	StudioCMSPageFolderStructure: 'StudioCMSPageFolderStructure',
+	StudioCMSPermissions: 'StudioCMSPermissions',
+	StudioCMSPluginData: 'StudioCMSPluginData',
+	StudioCMSSessionTable: 'StudioCMSSessionTable',
+	StudioCMSUserResetTokens: 'StudioCMSUserResetTokens',
+	StudioCMSUsers: 'StudioCMSUsersTable',
+} as const;
+
+/**
+ * Type representing the mapping from AstroDB table names to Kysely table names.
+ */
+export type AstroDBToKyselyMap = typeof astroDBToKyselyMap;
+
+/**
+ * Type representing the drizzle inferSelect type for a given AstroDB table.
+ */
+export type AstroDBTableType<T extends AstroDBTableKeys> =
+	(typeof AstroDBTableSchema)[T]['$inferSelect'];
+
+/**
+ * Type representing the Kysely Insertable type for a given Kysely table.
+ */
+export type KyselyTableType<T extends KyselyTableKeys> = Insertable<
+	(typeof KyselyTableSchema)[T]['Encoded']
+>;
+
+/**
+ * Type representing the migration types for a given AstroDB table and its corresponding Kysely table.
+ */
+export type GetMigrationTypes<
+	AstroDB extends AstroDBTableKeys,
+	KyselyDB extends KyselyTableKeys = AstroDBToKyselyMap[AstroDB],
+> = {
+	astro: AstroDBTableType<AstroDB>;
+	kysely: KyselyTableType<KyselyDB>;
+};
+
+/**
+ * Type representing a migration Key pair between an AstroDB table and its corresponding Kysely table.
+ */
+export type MigrationPair = {
+	astroTable: AstroDBTableKeys;
+	kyselyTable: KyselyTableKeys;
+};
+
+/**
+ * Get the migration key pair for a given AstroDB table key.
+ *
+ * @param key - The AstroDB table key.
+ * @returns The migration key pair.
+ */
+export const getMigrationPairs = <T extends AstroDBTableKeys>(key: T): MigrationPair => {
+	return {
+		astroTable: key,
+		kyselyTable: astroDBToKyselyMap[key],
+	};
+};
+
+// type _exampleMapping = GetMigrationTypes<'StudioCMSUsers'>;
+// const _examplePair = getMigrationPairs('StudioCMSUsers');
+
+/**
+ * Type representing migration metadata for both AstroDB and Kysely tables.
+ */
+export type MigrationMetaTables = {
+	astro: {
+		[key in AstroDBTableKeys]: number;
+	};
+	kysely: {
+		[key in KyselyTableKeys]: number;
+	};
+};
+
+/**
+ * Retrieve migration metadata for both AstroDB and Kysely databases.
+ *
+ * @returns An object containing migration metadata for AstroDB and Kysely tables.
+ */
+export const migrationMeta = async (): Promise<MigrationMetaTables> => {
+	const astro = await getAstroDataMigrationMeta().catch(() => {
+		const emptyMeta = {} as { [key in AstroDBTableKeys]: number };
+		return emptyMeta;
+	});
+	const kysely = await getKyselyDataMigrationMeta().catch(() => {
+		const emptyMeta = {} as { [key in KyselyTableKeys]: number };
+		return emptyMeta;
+	});
+
+	return {
+		astro,
+		kysely,
+	};
+};

package/src/pages/data-migrations.ts

@@ -0,0 +1,268 @@
+import type { APIRoute } from 'astro';
+import { db } from '../db/astro-db-drizzle-client.js';
+import { getStudioCMSDb } from '../db/client.js';
+import logger from '../lib/logger.js';
+import { remapFunctions } from '../lib/remapUtils.js';
+import { jsonResponse } from '../lib/response-utils.js';
+import { AstroDBTableSchema } from '../lib/tableMap.js';
+
+const studioCMSDb = await getStudioCMSDb();
+
+async function migrateUsersTable() {
+	const astroUsers = await db.select().from(AstroDBTableSchema.StudioCMSUsers);
+
+	if (astroUsers.length > 0) {
+		const remappedData = remapFunctions.StudioCMSUsers(astroUsers);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSUsersTable')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} users.`);
+	}
+}
+
+async function migratePageDataTable() {
+	const astroPageData = await db.select().from(AstroDBTableSchema.StudioCMSPageData);
+
+	if (astroPageData.length > 0) {
+		const remappedData = remapFunctions.StudioCMSPageData(astroPageData);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSPageData')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} page data items.`);
+	}
+}
+
+async function migratePageFolderStructureTable() {
+	const astroPageFolders = await db.select().from(AstroDBTableSchema.StudioCMSPageFolderStructure);
+
+	if (astroPageFolders.length > 0) {
+		const remappedData = remapFunctions.StudioCMSPageFolderStructure(astroPageFolders);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSPageFolderStructure')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} page folder items.`);
+	}
+}
+
+async function migratePageDataTagsTable() {
+	const astroPageDataTags = await db.select().from(AstroDBTableSchema.StudioCMSPageDataTags);
+
+	if (astroPageDataTags.length > 0) {
+		const remappedData = remapFunctions.StudioCMSPageDataTags(astroPageDataTags);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSPageDataTags')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} page data tags.`);
+	}
+}
+
+async function migratePageDataCategoriesTable() {
+	const astroPageDataCategories = await db
+		.select()
+		.from(AstroDBTableSchema.StudioCMSPageDataCategories);
+
+	if (astroPageDataCategories.length > 0) {
+		const remappedData = remapFunctions.StudioCMSPageDataCategories(astroPageDataCategories);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSPageDataCategories')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} page data categories.`);
+	}
+}
+
+async function migratePluginDataTable() {
+	const astroPluginData = await db.select().from(AstroDBTableSchema.StudioCMSPluginData);
+
+	if (astroPluginData.length > 0) {
+		const remappedData = remapFunctions.StudioCMSPluginData(astroPluginData);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSPluginData')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} plugin data items.`);
+	}
+}
+
+async function migrateDynamicConfigSettingsTable() {
+	const astroConfigSettings = await db
+		.select()
+		.from(AstroDBTableSchema.StudioCMSDynamicConfigSettings);
+
+	if (astroConfigSettings.length > 0) {
+		const remappedData = remapFunctions.StudioCMSDynamicConfigSettings(astroConfigSettings);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSDynamicConfigSettings')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} dynamic config settings.`);
+	}
+}
+
+async function migrateApiKeysTable() {
+	const astroApiKeys = await db.select().from(AstroDBTableSchema.StudioCMSAPIKeys);
+
+	if (astroApiKeys.length > 0) {
+		const remappedData = remapFunctions.StudioCMSAPIKeys(astroApiKeys);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSAPIKeys')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} API keys.`);
+	}
+}
+
+async function migrateUserResetTokensTable() {
+	const astroResetTokens = await db.select().from(AstroDBTableSchema.StudioCMSUserResetTokens);
+
+	if (astroResetTokens.length > 0) {
+		const remappedData = remapFunctions.StudioCMSUserResetTokens(astroResetTokens);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSUserResetTokens')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} user reset tokens.`);
+	}
+}
+
+async function migrateOAuthAccountsTable() {
+	const astroOAuthAccounts = await db.select().from(AstroDBTableSchema.StudioCMSOAuthAccounts);
+
+	if (astroOAuthAccounts.length > 0) {
+		const remappedData = remapFunctions.StudioCMSOAuthAccounts(astroOAuthAccounts);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSOAuthAccounts')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} OAuth accounts.`);
+	}
+}
+
+async function migrateSessionTable() {
+	const astroSessions = await db.select().from(AstroDBTableSchema.StudioCMSSessionTable);
+
+	if (astroSessions.length > 0) {
+		const remappedData = remapFunctions.StudioCMSSessionTable(astroSessions);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSSessionTable')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} sessions.`);
+	}
+}
+
+async function migratePermissionsTable() {
+	const astroPermissions = await db.select().from(AstroDBTableSchema.StudioCMSPermissions);
+
+	if (astroPermissions.length > 0) {
+		const remappedData = remapFunctions.StudioCMSPermissions(astroPermissions);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSPermissions')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} permissions.`);
+	}
+}
+
+async function migrateDiffTrackingTable() {
+	const astroDiffTracking = await db.select().from(AstroDBTableSchema.StudioCMSDiffTracking);
+
+	if (astroDiffTracking.length > 0) {
+		const remappedData = remapFunctions.StudioCMSDiffTracking(astroDiffTracking);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSDiffTracking')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} diff tracking items.`);
+	}
+}
+
+async function migratePageContentTable() {
+	const astroPageContent = await db.select().from(AstroDBTableSchema.StudioCMSPageContent);
+
+	if (astroPageContent.length > 0) {
+		const remappedData = remapFunctions.StudioCMSPageContent(astroPageContent);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSPageContent')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} page content items.`);
+	}
+}
+
+async function migrateEmailVerificationTokensTable() {
+	const astroEmailTokens = await db
+		.select()
+		.from(AstroDBTableSchema.StudioCMSEmailVerificationTokens);
+
+	if (astroEmailTokens.length > 0) {
+		const remappedData = remapFunctions.StudioCMSEmailVerificationTokens(astroEmailTokens);
+
+		const insertResult = await studioCMSDb.db
+			.insertInto('StudioCMSEmailVerificationTokens')
+			.values(remappedData)
+			.executeTakeFirst();
+
+		logger.info(`Migrated ${insertResult.numInsertedOrUpdatedRows} email verification tokens.`);
+	}
+}
+
+export const POST: APIRoute = async () => {
+	try {
+		// Migrate Tables Without References First
+		await migrateUsersTable();
+		await migratePageDataTable();
+		await migratePageFolderStructureTable();
+		await migratePageDataTagsTable();
+		await migratePageDataCategoriesTable();
+		await migratePluginDataTable();
+		await migrateDynamicConfigSettingsTable();
+
+		// Then migrate tables with references
+		await migrateApiKeysTable();
+		await migrateUserResetTokensTable();
+		await migrateOAuthAccountsTable();
+		await migrateSessionTable();
+		await migratePermissionsTable();
+		await migrateDiffTrackingTable();
+		await migratePageContentTable();
+		await migrateEmailVerificationTokensTable();
+	} catch (error) {
+		logger.error(`Migration failed: ${(error as Error).message}`);
+		return jsonResponse({ success: false, error: 'Migration failed' }, 500);
+	}
+
+	return jsonResponse({ success: true });
+};