@stacksjs/cms 0.70.53 → 0.70.55

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/cms",
   "type": "module",
-  "version": "0.70.53",
+  "version": "0.70.55",
   "description": "Stacks cms utilities.",
   "author": "Chris Breuer",
   "contributors": [
@@ -40,7 +40,8 @@
   "types": "dist/index.d.ts",
   "files": [
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun build.ts",

package/src/authors/destroy.ts

@@ -0,0 +1,55 @@
+type AuthorJsonResponse = ModelRow<typeof Author>
+import { getDb } from '../database'
+
+/**
+ * Delete an author by ID
+ *
+ * @param id The ID of the author to delete
+ * @returns The deleted author record
+ */
+export async function destroy(id: number): Promise<AuthorJsonResponse> {
+  const db = await getDb()
+  try {
+    const result = await db
+      .deleteFrom('authors')
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result) {
+      throw new Error(`Author with ID ${id} not found`)
+    }
+
+    return result as AuthorJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Author with ID ${id} not found`)
+
+    throw error
+  }
+}
+
+/**
+ * Delete multiple authors by IDs
+ *
+ * @param ids Array of author IDs to delete
+ * @returns The number of deleted authors
+ */
+export async function destroyMany(ids: number[]): Promise<number> {
+  const db = await getDb()
+  try {
+    const result = await db
+      .deleteFrom('authors')
+      .where('id', 'in', ids)
+      .execute()
+
+    return Number(result) || 0
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to delete authors: ${error.message}`)
+
+    throw error
+  }
+}

package/src/authors/fetch.ts

@@ -0,0 +1,70 @@
+type AuthorJsonResponse = ModelRow<typeof Author>
+import { getDb } from '../database'
+
+/**
+ * Fetch an author by ID
+ */
+export async function fetchById(id: number): Promise<AuthorJsonResponse | undefined> {
+  const db = await getDb()
+  return await db
+    .selectFrom('authors')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as AuthorJsonResponse | undefined
+}
+
+/**
+ * Fetch all authors
+ */
+export async function fetchAll(): Promise<AuthorJsonResponse[]> {
+  const db = await getDb()
+  return await db.selectFrom('authors').selectAll().execute() as AuthorJsonResponse[]
+}
+
+/**
+ * Fetch authors by name
+ */
+export async function findByName(name: string): Promise<AuthorJsonResponse | undefined> {
+  const db = await getDb()
+  return await db
+    .selectFrom('authors')
+    .where('name', '=', name)
+    .selectAll()
+    .executeTakeFirst() as AuthorJsonResponse | undefined
+}
+
+/**
+ * Fetch authors by email
+ */
+export async function findByEmail(email: string): Promise<AuthorJsonResponse | undefined> {
+  const db = await getDb()
+  return await db
+    .selectFrom('authors')
+    .where('email', '=', email)
+    .selectAll()
+    .executeTakeFirst() as AuthorJsonResponse | undefined
+}
+
+/**
+ * Fetch author by UUID
+ */
+export async function findByUuid(uuid: string): Promise<AuthorJsonResponse | undefined> {
+  const db = await getDb()
+  return await db
+    .selectFrom('authors')
+    .where('uuid', '=', uuid)
+    .selectAll()
+    .executeTakeFirst() as AuthorJsonResponse | undefined
+}
+
+/**
+ * Fetch authors by user ID
+ */
+export async function findByUserId(userId: number): Promise<AuthorJsonResponse | undefined> {
+  const db = await getDb()
+  return await db
+    .selectFrom('authors')
+    .where('user_id', '=', userId)
+    .selectAll()
+    .executeTakeFirst() as AuthorJsonResponse | undefined
+}

package/src/authors/index.ts

@@ -0,0 +1,21 @@
+export {
+  destroy,
+} from './destroy'
+
+export {
+  fetchAll,
+  fetchById,
+  findByEmail,
+  findByName,
+  findByUserId,
+  findByUuid,
+} from './fetch'
+
+export {
+  findOrCreate,
+  store,
+} from './store'
+
+export {
+  update,
+} from './update'

package/src/authors/store.ts

@@ -0,0 +1,150 @@
+type AuthorJsonResponse = ModelRow<typeof Author>
+type NewAuthor = NewModelData<typeof Author>
+import { randomUUIDv7 } from 'bun'
+import { getDb } from '../database'
+import { HttpError } from '@stacksjs/error-handling'
+import { formatDate, isUniqueViolation } from '@stacksjs/orm'
+
+interface AuthorData {
+  name: string
+  email: string
+}
+/**
+ * Find an existing author by name or email, or create a new one if not found
+ *
+ * @param data The author data to find or create
+ * @returns The found or created author record
+ */
+export async function findOrCreate(data: AuthorData): Promise<AuthorJsonResponse> {
+  const db = await getDb()
+  try {
+    // First, try to find an existing author by email or name
+    const existingAuthor = await db
+      .selectFrom('authors')
+      .where((eb: any) => eb.or([
+        eb('email', '=', data.email),
+        eb('name', '=', data.name),
+      ]))
+      .selectAll()
+      .executeTakeFirst()
+
+    // If author exists, return it
+    if (existingAuthor)
+      return existingAuthor as AuthorJsonResponse
+
+    // Look up or create the associated user
+    let user = await db
+      .selectFrom('users')
+      .where('email', '=', data.email)
+      .selectAll()
+      .executeTakeFirst()
+
+    if (!user) {
+      // Create a new user if one doesn't exist
+      const result = await db
+        .insertInto('users')
+        .values({
+          email: data.email,
+          name: data.name,
+          password: randomUUIDv7(),
+          uuid: randomUUIDv7(),
+          created_at: formatDate(new Date()),
+          updated_at: formatDate(new Date()),
+        })
+        .returningAll()
+        .executeTakeFirst()
+
+      if (!result)
+        throw new Error('Failed to create user')
+
+      user = result
+    }
+
+    // Create a new author with the user_id
+    const authorData = {
+      user_id: (user as Record<string, unknown>).id as number,
+      name: data.name,
+      email: data.email,
+      created_at: formatDate(new Date()),
+      updated_at: formatDate(new Date()),
+    }
+
+    const result = await db
+      .insertInto('authors')
+      .values(authorData)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create author')
+
+    return result as AuthorJsonResponse
+  }
+  catch (error) {
+    if (error instanceof HttpError)
+      throw error
+    // A concurrent insert can lose the find-then-insert race on the
+    // authors.email / users.email unique index (#1957).
+    if (isUniqueViolation(error))
+      throw new HttpError(409, 'An author with this email already exists')
+    if (error instanceof Error)
+      throw new TypeError(`Failed to find or create author: ${error.message}`)
+
+    throw error
+  }
+}
+
+/**
+ * Find or create an author by name or email
+ *
+ * @param data The author data to find or create
+ * @returns The found or created author record
+ */
+export async function store(data: NewAuthor): Promise<AuthorJsonResponse> {
+  const db = await getDb()
+  try {
+    // First, try to find an existing author by email or name
+    const existingAuthor = await db
+      .selectFrom('authors')
+      .where((eb: any) => eb.or([
+        eb('email', '=', data.email),
+        eb('name', '=', data.name),
+      ]))
+      .selectAll()
+      .executeTakeFirst()
+
+    // If author exists, return it
+    if (existingAuthor)
+      return existingAuthor as AuthorJsonResponse
+
+    // If no existing author, create a new one
+    const authorData = {
+      user_id: data.user_id,
+      name: data.name,
+      email: data.email,
+      created_at: formatDate(new Date()),
+      updated_at: formatDate(new Date()),
+    }
+
+    const result = await db
+      .insertInto('authors')
+      .values(authorData)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create author')
+
+    return result as AuthorJsonResponse
+  }
+  catch (error) {
+    if (error instanceof HttpError)
+      throw error
+    if (isUniqueViolation(error))
+      throw new HttpError(409, 'An author with this email already exists')
+    if (error instanceof Error)
+      throw new TypeError(`Failed to find or create author: ${error.message}`)
+
+    throw error
+  }
+}

package/src/authors/update.ts

@@ -0,0 +1,42 @@
+type AuthorJsonResponse = ModelRow<typeof Author>
+type NewAuthor = NewModelData<typeof Author>
+import { getDb } from '../database'
+import { HttpError } from '@stacksjs/error-handling'
+import { formatDate, isUniqueViolation } from '@stacksjs/orm'
+
+/**
+ * Update an existing author
+ *
+ * @param id The ID of the author to update
+ * @param data The author data to update
+ * @returns The updated author record
+ */
+export async function update(id: number, data: Partial<NewAuthor>): Promise<AuthorJsonResponse | undefined> {
+  const db = await getDb()
+  try {
+    const updateData = {
+      ...data,
+      updated_at: formatDate(new Date()),
+    }
+
+    const result = await db
+      .updateTable('authors')
+      .set(updateData)
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    return result as AuthorJsonResponse | undefined
+  }
+  catch (error) {
+    if (error instanceof HttpError)
+      throw error
+    // Duplicate authors.email on update (#1957).
+    if (isUniqueViolation(error))
+      throw new HttpError(409, 'An author with this email already exists')
+    if (error instanceof Error)
+      throw new TypeError(`Failed to update author: ${error.message}`)
+
+    throw error
+  }
+}