@maestro-js/agent-skills 1.0.0-alpha.2 → 1.0.0-alpha.21

package/skills/maestro-examples/references/chorus/packages/services/src/post/post-use-cases.ts

@@ -0,0 +1,184 @@
+import z from 'zod'
+import { PostSchemas, ProfileSchemas } from '@chorus/schemas'
+import { Db } from '@maestro-js/db'
+import { CustomErrors } from '@maestro-js/custom-errors'
+import { Permissions } from '@maestro-js/permissions'
+import { FileStorage } from '@maestro-js/file-storage'
+import { Log } from '@maestro-js/log'
+import { channelDbProvider } from '../channel/channel-db-provider.ts'
+import { postDbProvider } from './post-db-provider.ts'
+import { redactHiddenPost } from './redact-hidden-post.ts'
+import { likeDbProvider } from '../like/like-db-provider.ts'
+import { ChannelNotFoundError } from '../channel/channel-use-cases.ts'
+
+export const PostNotFoundError = CustomErrors.create({
+  name: 'PostNotFound',
+  message: 'Post not found'
+})
+
+export const CannotReplyToReplyError = CustomErrors.create({
+  name: 'CannotReplyToReply',
+  message: 'Replies can only be made to top-level posts'
+})
+
+export const CreatePost = z
+  .function({
+    input: [PostSchemas.createPostSchema.extend({ channelId: z.number() }), ProfileSchemas.Profile]
+  })
+  .implement(async ({ channelId, content, images }, profile) => {
+    const channel = await channelDbProvider.getChannelById(channelId)
+    if (!channel) throw new ChannelNotFoundError()
+
+    let postId: number
+
+    await Db.transaction(async () => {
+      postId = await postDbProvider.createPost({ channelId, profileId: profile.profileId, content })
+
+      if (images && images.length > 0) {
+        await postDbProvider.insertImages(postId, images)
+      }
+    })
+
+    Log.info({ channel: 'community', action: 'post.created', profileId: profile.profileId, channelId, postId: postId! })
+
+    return postId!
+  })
+
+export const CreateReply = z
+  .function({
+    input: [PostSchemas.createReplySchema.extend({ postId: z.number() }), ProfileSchemas.Profile]
+  })
+  .implement(async ({ postId, content, images }, profile) => {
+    const parentPost = await postDbProvider.getPostById(postId)
+    if (!parentPost) throw new PostNotFoundError()
+
+    let replyId: number
+
+    await Db.transaction(async () => {
+      replyId = await postDbProvider.createPost({
+        channelId: parentPost.channelId,
+        profileId: profile.profileId,
+        content,
+        replyingToPostId: postId
+      })
+
+      if (images && images.length > 0) {
+        await postDbProvider.insertImages(replyId, images)
+      }
+    })
+
+    Log.info({
+      channel: 'community',
+      action: 'reply.created',
+      profileId: profile.profileId,
+      channelId: parentPost.channelId,
+      postId,
+      replyId: replyId!
+    })
+
+    return replyId!
+  })
+
+export const ViewPost = z
+  .function({
+    input: [z.object({ postId: z.number() }), ProfileSchemas.Profile.nullable()]
+  })
+  .implement(async ({ postId }, profile) => {
+    function fetchData() {
+      const postRaw = postDbProvider.getPostById(postId).then((post) => {
+        if (!post) throw new PostNotFoundError()
+        return post
+      })
+
+      const repliesRaw = postDbProvider.listRepliesByPostId(postId)
+
+      const allPostIds = repliesRaw.then((replies) => [postId, ...replies.map((r) => r.id)])
+
+      const likedByUser = profile
+        ? allPostIds.then((allPostIds) => likeDbProvider.batchHasLiked(allPostIds, profile.profileId))
+        : new Set<number>()
+
+      const replies = Promise.all([repliesRaw, likedByUser]).then(([postsRaw, likedByUser]) => {
+        return postsRaw.map((post) => ({
+          ...post,
+          likedByCurrentUser: likedByUser.has(post.id)
+        }))
+      })
+
+      const post = Promise.all([postRaw, likedByUser]).then(([postRaw, likedByUser]) => {
+        return {
+          ...postRaw,
+          likedByCurrentUser: likedByUser.has(postRaw.id)
+        }
+      })
+
+      return { post, replies }
+    }
+
+    const promises = fetchData()
+
+    return {
+      post: redactHiddenPost(await promises.post),
+      replies: await promises.replies
+    }
+  })
+
+export const HidePost = z
+  .function({
+    input: [z.object({ postId: z.number() }), ProfileSchemas.Profile]
+  })
+  .implement(async ({ postId }, profile) => {
+    const post = await postDbProvider.getPostById(postId)
+    if (!post) throw new PostNotFoundError()
+
+    const isAuthor = post.profileId === profile.profileId
+    const channel = await channelDbProvider.getChannelById(post.channelId)
+    const isOwner = channel?.ownerProfileId === profile.profileId
+
+    if (!isAuthor && !channel?.moderatorProfileIds.includes(profile.profileId) && !isOwner) {
+      Log.warn({
+        channel: 'community',
+        action: 'post.hide.denied',
+        profileId: profile.profileId,
+        postId,
+        reason: 'not_authorized'
+      })
+      throw new Permissions.PermissionsError({ action: 'hide', subject: 'post' })
+    }
+
+    await postDbProvider.hidePost(postId)
+
+    Log.info({ channel: 'community', action: 'post.hidden', profileId: profile.profileId, postId })
+  })
+
+const ALLOWED_MIME_TYPES = ['image/jpeg', 'image/png', 'image/gif', 'image/webp']
+const MAX_FILE_SIZE = 5 * 1024 * 1024 // 5MB
+
+export const InvalidImageTypeError = CustomErrors.create({
+  name: 'InvalidImageType',
+  message: 'Only JPEG, PNG, GIF, and WebP images are allowed'
+})
+
+export const ImageTooLargeError = CustomErrors.create({
+  name: 'ImageTooLarge',
+  message: 'Image must be less than 5MB'
+})
+
+export const UploadImage = z
+  .function({
+    input: [z.object({ file: z.custom<File>() }), ProfileSchemas.Profile]
+  })
+  .implement(async ({ file }, profile) => {
+    if (!ALLOWED_MIME_TYPES.includes(file.type)) {
+      throw new InvalidImageTypeError()
+    }
+
+    if (file.size > MAX_FILE_SIZE) {
+      throw new ImageTooLargeError()
+    }
+
+    const path = await FileStorage.putFile(`post-images`, file)
+    const url = FileStorage.url(path)
+
+    return { url }
+  })

package/skills/maestro-examples/references/chorus/packages/services/src/post/redact-hidden-post.ts

@@ -0,0 +1,4 @@
+export function redactHiddenPost<T extends { hiddenDate: unknown; content: string; images: string[] }>(post: T): T {
+  if (!post.hiddenDate) return post
+  return { ...post, content: '', images: [] }
+}

package/skills/maestro-examples/references/chorus/packages/services/src/profile/index.ts

@@ -0,0 +1,17 @@
+import {
+  UpdateProfile,
+  UploadProfileImage,
+  UsernameTakenError,
+  InvalidImageTypeError,
+  ImageTooLargeError
+} from './profile-use-cases.ts'
+
+export const ProfileService = {
+  UpdateProfile,
+  UploadProfileImage,
+  errors: {
+    UsernameTakenError,
+    InvalidImageTypeError,
+    ImageTooLargeError
+  }
+}

package/skills/maestro-examples/references/chorus/packages/services/src/profile/profile-db-provider.test.ts

@@ -0,0 +1,57 @@
+import { test } from 'beartest-js'
+import { expect } from 'expect'
+import { profileDbProvider } from './profile-db-provider.ts'
+
+const createdIds: number[] = []
+
+test.afterEach(async () => {
+  for (const id of createdIds) {
+    await profileDbProvider.hardDelete(id)
+  }
+  createdIds.length = 0
+})
+
+test('createProfile and getProfileById', async () => {
+  const id = await profileDbProvider.createProfile({
+    email: 'alice@test.com',
+    passwordHash: '$2b$10$abcdefghijklmnopqrstuuABCDEFGHIJKLMNOPQRSTUVWXYZ012',
+    username: 'alice',
+    profileImage: 'https://example.com/alice.png'
+  })
+  createdIds.push(id)
+  const profile = await profileDbProvider.getProfileById(id)
+  expect(profile).not.toBeNull()
+  expect(profile!.email).toBe('alice@test.com')
+  expect(profile!.username).toBe('alice')
+  expect(profile!.profileImage).toBe('https://example.com/alice.png')
+})
+
+test('updateProfile', async () => {
+  const id = await profileDbProvider.createProfile({
+    email: 'bob@test.com',
+    passwordHash: '$2b$10$abcdefghijklmnopqrstuuABCDEFGHIJKLMNOPQRSTUVWXYZ012',
+    username: 'bob',
+    profileImage: 'https://example.com/bob.png'
+  })
+  createdIds.push(id)
+  await profileDbProvider.updateProfile(id, { username: 'bob-updated', profileImage: 'https://example.com/bob2.png' })
+  const profile = await profileDbProvider.getProfileById(id)
+  expect(profile!.username).toBe('bob-updated')
+  expect(profile!.profileImage).toBe('https://example.com/bob2.png')
+})
+
+test('getProfileByUsername', async () => {
+  const id = await profileDbProvider.createProfile({
+    email: 'carol@test.com',
+    passwordHash: '$2b$10$abcdefghijklmnopqrstuuABCDEFGHIJKLMNOPQRSTUVWXYZ012',
+    username: 'carol',
+    profileImage: 'https://example.com/carol.png'
+  })
+  createdIds.push(id)
+  const result = await profileDbProvider.getProfileByUsername('carol')
+  expect(result).not.toBeNull()
+  expect(result!.profileId).toBe(id)
+
+  const missing = await profileDbProvider.getProfileByUsername('nobody')
+  expect(missing).toBeNull()
+})

package/skills/maestro-examples/references/chorus/packages/services/src/profile/profile-db-provider.ts

@@ -0,0 +1,75 @@
+import { Db } from '@maestro-js/db'
+import { ProfileSchemas } from '@chorus/schemas'
+import { instantFns } from 'iso-fns'
+import { z } from 'zod'
+
+async function createProfile(data: {
+  email: string
+  passwordHash: string
+  username: string
+  profileImage: string
+}): Promise<number> {
+  const createdDate = instantFns.now()
+  const result = await Db.insert(
+    'INSERT INTO profiles (email, passwordHash, username, profileImage, lastModifiedDate, createdDate) VALUES (?, ?, ?, ?, ?, ?)',
+    [
+      data.email,
+      data.passwordHash,
+      data.username,
+      data.profileImage,
+      instantFns.formatISO9075(createdDate),
+      instantFns.formatISO9075(createdDate)
+    ]
+  )
+  return result.insertId
+}
+
+async function getProfileById(id: number): Promise<z.infer<typeof ProfileSchemas.Profile> | null> {
+  const rows = await Db.select('SELECT profileId, email, username, profileImage FROM profiles WHERE profileId = ?', [id])
+  return rows.length ? ProfileSchemas.Profile.parse(rows[0]) : null
+}
+
+async function updateProfile(profileId: number, data: { username: string; profileImage?: string | null }): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+
+  if (data.profileImage !== undefined) {
+    await Db.update('UPDATE profiles SET username = ?, profileImage = ?, lastModifiedDate = ? WHERE profileId = ?', [
+      data.username,
+      data.profileImage,
+      now,
+      profileId
+    ])
+  } else {
+    await Db.update('UPDATE profiles SET username = ?, lastModifiedDate = ? WHERE profileId = ?', [
+      data.username,
+      now,
+      profileId
+    ])
+  }
+}
+
+async function getProfileByUsername(username: string): Promise<{ profileId: number } | null> {
+  const rows = await Db.select<{ profileId: number }>('SELECT profileId FROM profiles WHERE username = ?', [username])
+  return rows[0] ?? null
+}
+
+async function seedCreate(data: ProfileSchemas.profileModel & { passwordHash: string }): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  await Db.insert(
+    'INSERT INTO profiles (profileId, email, passwordHash, username, profileImage, lastModifiedDate, createdDate) VALUES (?, ?, ?, ?, ?, ?, ?)',
+    [data.profileId, data.email, data.passwordHash, data.username, data.profileImage, now, now]
+  )
+}
+
+async function hardDelete(profileId: number): Promise<void> {
+  await Db.delete('DELETE FROM profiles WHERE profileId = ?', [profileId])
+}
+
+export const profileDbProvider = {
+  createProfile,
+  getProfileById,
+  updateProfile,
+  getProfileByUsername,
+  seedCreate,
+  hardDelete
+}

package/skills/maestro-examples/references/chorus/packages/services/src/profile/profile-use-cases.ts

@@ -0,0 +1,61 @@
+import z from 'zod'
+import { ProfileSchemas } from '@chorus/schemas'
+import { CustomErrors } from '@maestro-js/custom-errors'
+import { FileStorage } from '@maestro-js/file-storage'
+import { Log } from '@maestro-js/log'
+import { profileDbProvider } from './profile-db-provider.ts'
+
+export const UsernameTakenError = CustomErrors.create({
+  name: 'UsernameTaken',
+  message: 'That username is already taken'
+})
+
+const ALLOWED_MIME_TYPES = ['image/jpeg', 'image/png', 'image/gif', 'image/webp']
+const MAX_FILE_SIZE = 5 * 1024 * 1024 // 5MB
+
+export const InvalidImageTypeError = CustomErrors.create({
+  name: 'InvalidProfileImageType',
+  message: 'Only JPEG, PNG, GIF, and WebP images are allowed'
+})
+
+export const ImageTooLargeError = CustomErrors.create({
+  name: 'ProfileImageTooLarge',
+  message: 'Image must be less than 5MB'
+})
+
+export const UpdateProfile = z
+  .function({
+    input: [ProfileSchemas.updateProfileSchema, ProfileSchemas.Profile]
+  })
+  .implement(async ({ username, profileImage }, profile) => {
+    const existing = await profileDbProvider.getProfileByUsername(username)
+    if (existing && existing.profileId !== profile.profileId) {
+      throw new UsernameTakenError()
+    }
+
+    await profileDbProvider.updateProfile(profile.profileId, {
+      username,
+      ...(profileImage !== undefined ? { profileImage } : {})
+    })
+
+    Log.info({ channel: 'community', action: 'profile.updated', profileId: profile.profileId })
+  })
+
+export const UploadProfileImage = z
+  .function({
+    input: [z.object({ file: z.custom<File>() }), ProfileSchemas.Profile]
+  })
+  .implement(async ({ file }, profile) => {
+    if (!ALLOWED_MIME_TYPES.includes(file.type)) {
+      throw new InvalidImageTypeError()
+    }
+
+    if (file.size > MAX_FILE_SIZE) {
+      throw new ImageTooLargeError()
+    }
+
+    const path = await FileStorage.putFile('profile-images', file)
+    const url = FileStorage.url(path)
+
+    return { url }
+  })

package/skills/maestro-examples/references/chorus/packages/services/src/testing/channel-seed.ts

@@ -0,0 +1,27 @@
+import type { ChannelSchemas } from '@chorus/schemas'
+import { instantFns } from 'iso-fns'
+import { channelDbProvider } from '../channel/channel-db-provider.ts'
+
+export function ChannelSeed(
+  channel: Partial<Omit<ChannelSchemas.channelModel, 'moderatorProfileIds'>> & { id: number; ownerProfileId: number }
+) {
+  const mock: Omit<ChannelSchemas.channelModel, 'id' | 'ownerProfileId' | 'moderatorProfileIds'> = {
+    name: `Test Channel ${channel.id}`,
+    slug: `test-channel-${channel.id}`,
+    description: 'A test channel',
+    createdDate: instantFns.now(),
+    lastModifiedDate: instantFns.now()
+  }
+  const merged = { ...mock, ...channel }
+
+  async function setup() {
+    await teardown()
+    await channelDbProvider.seedCreate(merged)
+  }
+
+  async function teardown() {
+    await channelDbProvider.hardDelete(merged.id)
+  }
+
+  return { setup, teardown }
+}

package/skills/maestro-examples/references/chorus/packages/services/src/testing/index.ts

@@ -0,0 +1,13 @@
+import { ChannelSeed } from './channel-seed.ts'
+import { LikeSeed } from './like-seed.ts'
+import { PostSeed } from './post-seed.ts'
+import { ProfileSeed } from './profile-seed.ts'
+import { SeedPipe } from './seed-pipe.ts'
+
+export const H = {
+  ChannelSeed,
+  LikeSeed,
+  PostSeed,
+  ProfileSeed,
+  SeedPipe
+}

package/skills/maestro-examples/references/chorus/packages/services/src/testing/like-seed.ts

@@ -0,0 +1,21 @@
+import type { LikeSchemas } from '@chorus/schemas'
+import { instantFns } from 'iso-fns'
+import { likeDbProvider } from '../like/like-db-provider.ts'
+
+export function LikeSeed(like: Partial<LikeSchemas.likeModel> & { postId: number; profileId: number }) {
+  const mock: Omit<LikeSchemas.likeModel, 'postId' | 'profileId'> = {
+    createdDate: instantFns.now()
+  }
+  const merged = { ...mock, ...like }
+
+  async function setup() {
+    await teardown()
+    await likeDbProvider.seedCreate(merged)
+  }
+
+  async function teardown() {
+    await likeDbProvider.hardDelete(merged.postId, merged.profileId)
+  }
+
+  return { setup, teardown }
+}

package/skills/maestro-examples/references/chorus/packages/services/src/testing/post-seed.ts

@@ -0,0 +1,27 @@
+import type { PostSchemas } from '@chorus/schemas'
+import { instantFns } from 'iso-fns'
+import { postDbProvider } from '../post/post-db-provider.ts'
+
+export function PostSeed(
+  post: Partial<Omit<PostSchemas.postModel, 'images'>> & { id: number; channelId: number; profileId: number }
+) {
+  const mock: Omit<PostSchemas.postModel, 'id' | 'channelId' | 'profileId' | 'images'> = {
+    content: 'Test post content',
+    replyingToPostId: null,
+    hiddenDate: null,
+    createdDate: instantFns.now(),
+    lastModifiedDate: instantFns.now()
+  }
+  const merged = { ...mock, ...post }
+
+  async function setup() {
+    await teardown()
+    await postDbProvider.seedCreate(merged)
+  }
+
+  async function teardown() {
+    await postDbProvider.hardDelete(merged.id)
+  }
+
+  return { setup, teardown }
+}

package/skills/maestro-examples/references/chorus/packages/services/src/testing/profile-seed.ts

@@ -0,0 +1,28 @@
+import type { ProfileSchemas } from '@chorus/schemas'
+import { instantFns } from 'iso-fns'
+import { profileDbProvider } from '../profile/profile-db-provider.ts'
+
+export function ProfileSeed(
+  profile: Partial<ProfileSchemas.profileModel & { passwordHash: string }> & { profileId: number }
+) {
+  const mock: Omit<ProfileSchemas.profileModel, 'profileId'> & { passwordHash: string } = {
+    email: `test-${profile.profileId}@example.com`,
+    passwordHash: '$2b$10$abcdefghijklmnopqrstuuABCDEFGHIJKLMNOPQRSTUVWXYZ012',
+    username: `test-user-${profile.profileId}`,
+    profileImage: 'https://example.com/default.png',
+    createdDate: instantFns.formatISO9075(instantFns.now()),
+    lastModifiedDate: instantFns.formatISO9075(instantFns.now())
+  }
+  const merged = { ...mock, ...profile }
+
+  async function setup() {
+    await teardown()
+    await profileDbProvider.seedCreate(merged)
+  }
+
+  async function teardown() {
+    await profileDbProvider.hardDelete(merged.profileId)
+  }
+
+  return { setup, teardown }
+}

package/skills/maestro-examples/references/chorus/packages/services/src/testing/seed-pipe.ts

@@ -0,0 +1,38 @@
+export type SeedFn = { setup(): Promise<void>; teardown: () => Promise<void> }
+
+export function SeedPipe(...seeds: SeedFn[]): SeedFn {
+  const seedFnMap = new Map<() => Promise<SeedFn>, Promise<SeedFn>>()
+
+  function resolveSeeder(seeder: SeedFn | (() => Promise<SeedFn>)): Promise<SeedFn> {
+    if (typeof seeder === 'function') {
+      const existing = seedFnMap.get(seeder)
+      if (existing) {
+        return existing
+      } else {
+        seedFnMap.set(seeder, seeder())
+        return seedFnMap.get(seeder)!
+      }
+    } else {
+      return Promise.resolve(seeder)
+    }
+  }
+
+  async function setup() {
+    for (const seed of seeds) {
+      const seeder = await resolveSeeder(seed)
+      await seeder.setup()
+    }
+  }
+
+  async function teardown() {
+    const seedsReversed = [...seeds].reverse()
+    for (const seed of seedsReversed) {
+      const seeder = await resolveSeeder(seed)
+      await seeder.teardown()
+    }
+  }
+  return {
+    setup,
+    teardown
+  }
+}

package/skills/maestro-examples/references/chorus/packages/services/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "es2022",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true
+  },
+  "include": ["./src", "./environment.d.ts"]
+}

package/skills/maestro-examples/references/chorus/scripts/foreign-key-delete-behavior.ts

@@ -0,0 +1,111 @@
+import { Db } from '@maestro-js/db'
+
+Db.Provider.register(
+  'default',
+  Db.Provider.create({
+    driver: Db.drivers.mysql({
+      user: process.env.DB_USER!,
+      password: process.env.DB_PASSWORD!,
+      host: process.env.DB_HOSTNAME!,
+      database: process.env.DB_DATABASE!,
+      port: Number(process.env.DB_PORT!)
+    })
+  })
+)
+
+const FKS = {
+  fk_channelModerators_channelId: 'CASCADE',
+  fk_channelModerators_profileId: 'CASCADE',
+  fk_channels_ownerProfileId: 'CASCADE',
+  fk_likes_postId: 'CASCADE',
+  fk_likes_profileId: 'CASCADE',
+  fk_password_reset_tokens_profile_id: 'CASCADE',
+  fk_postImages_postId: 'CASCADE',
+  fk_posts_channelId: 'CASCADE',
+  fk_posts_profileId: 'CASCADE',
+  fk_posts_replyingToPostId: 'CASCADE',
+  fk_remember_me_tokens_profile_id: 'CASCADE'
+}
+
+type ForeignKey = {
+  TABLE_NAME: string
+  COLUMN_NAME: string
+  REFERENCED_TABLE_NAME: string
+  REFERENCED_COLUMN_NAME: string
+  CONSTRAINT_NAME: string
+}
+
+const foreignKeys = await Db.select<ForeignKey>(
+  `SELECT
+    TABLE_NAME,
+    COLUMN_NAME,
+    REFERENCED_TABLE_NAME,
+    REFERENCED_COLUMN_NAME,
+    CONSTRAINT_NAME
+  FROM information_schema.KEY_COLUMN_USAGE
+  WHERE TABLE_SCHEMA = ?
+    AND REFERENCED_TABLE_NAME IS NOT NULL
+  ORDER BY TABLE_NAME, COLUMN_NAME`,
+  [process.env.DB_DATABASE!]
+)
+
+const dbFkNames = new Set(foreignKeys.map((fk) => fk.CONSTRAINT_NAME))
+const localFkNames = new Set(Object.keys(FKS))
+
+const missingFromLocal = [...dbFkNames].filter((name) => !localFkNames.has(name))
+const extraInLocal = [...localFkNames].filter((name) => !dbFkNames.has(name))
+
+if (missingFromLocal.length > 0) {
+  console.error('Foreign keys in database but missing from FKS:', missingFromLocal)
+}
+if (extraInLocal.length > 0) {
+  console.error('Foreign keys in FKS but not in database:', extraInLocal)
+}
+if (missingFromLocal.length > 0 || extraInLocal.length > 0) {
+  process.exit(1)
+}
+
+console.log('FKS matches database foreign keys')
+
+async function applyOnDeleteRestrict() {
+  for (const constraintName of Object.keys(FKS)) {
+    const fk = foreignKeys.find((f) => f.CONSTRAINT_NAME === constraintName)!
+    await Db.statement(`ALTER TABLE ${fk.TABLE_NAME} DROP FOREIGN KEY ${constraintName}`)
+    await Db.statement(
+      `ALTER TABLE ${fk.TABLE_NAME}
+        ADD CONSTRAINT ${constraintName}
+        FOREIGN KEY (${fk.COLUMN_NAME})
+        REFERENCES ${fk.REFERENCED_TABLE_NAME}(${fk.REFERENCED_COLUMN_NAME})
+        ON DELETE RESTRICT`
+    )
+    console.log(`${constraintName}: ON DELETE RESTRICT applied`)
+  }
+}
+
+async function applyOnDeleteCascade() {
+  for (const [constraintName, behavior] of Object.entries(FKS)) {
+    const fk = foreignKeys.find((f) => f.CONSTRAINT_NAME === constraintName)!
+    await Db.statement(`ALTER TABLE ${fk.TABLE_NAME} DROP FOREIGN KEY ${constraintName}`)
+    await Db.statement(
+      `ALTER TABLE ${fk.TABLE_NAME}
+        ADD CONSTRAINT ${constraintName}
+        FOREIGN KEY (${fk.COLUMN_NAME})
+        REFERENCES ${fk.REFERENCED_TABLE_NAME}(${fk.REFERENCED_COLUMN_NAME})
+        ON DELETE ${behavior}`
+    )
+    console.log(`${constraintName}: ON DELETE ${behavior} applied`)
+  }
+}
+
+const action = process.argv[2]
+
+if (action === 'cascade') {
+  await applyOnDeleteCascade()
+} else if (action === 'restrict') {
+  await applyOnDeleteRestrict()
+} else {
+  console.error('Usage: foreign-key-delete-behavior <cascade|restrict>')
+  process.exit(1)
+}
+
+process.exit(0)