@stacksjs/cms 0.70.55 → 0.70.57

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/cms",
   "type": "module",
-  "version": "0.70.55",
+  "version": "0.70.57",
   "description": "Stacks cms utilities.",
   "author": "Chris Breuer",
   "contributors": [
@@ -28,20 +28,23 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "bun": "./src/index.ts",
-      "import": "./dist/index.js"
+      "development": "./src/index.ts",
+      "bun": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./*": {
-      "bun": "./src/*",
-      "import": "./dist/*"
+      "development": "./src/*",
+      "bun": "./dist/*",
+      "import": "./dist/*",
+      "default": "./dist/*"
     }
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "README.md",
-    "dist",
-    "src"
+    "dist"
   ],
   "scripts": {
     "build": "bun build.ts",

package/src/authors/destroy.ts

@@ -1,55 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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
-  }
-}