kmcom-nuxt-layers 2.3.2 → 2.5.0

package/layers/metadata-comicvine/server/utils/metadata-comicvine/client.ts

@@ -0,0 +1,52 @@
+import type { ComicVineApiResponse } from './types'
+
+const FIELD_LIST_ISSUE = 'id,name,issue_number,description,deck,cover_date,store_date,site_detail_url,image,volume,person_credits,publisher'
+const FIELD_LIST_VOLUME = 'id,name,description,deck,start_year,site_detail_url,image,publisher,people'
+
+function getConfig() {
+  const config = useRuntimeConfig()
+  return config.metadataComicvine
+}
+
+async function comicVineFetch<T>(path: string, params: Record<string, string>): Promise<ComicVineApiResponse<T>> {
+  const { apiKey, baseUrl } = getConfig()
+
+  const url = new URL(`${baseUrl}${path}`)
+  url.searchParams.set('api_key', apiKey)
+  url.searchParams.set('format', 'json')
+  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v)
+
+  const res = await $fetch<ComicVineApiResponse<T>>(url.toString())
+  if (res.status_code !== 1) throw new MetadataProviderError('comicvine', `API error: ${res.error}`)
+  return res
+}
+
+export async function searchComicVineIssues(query: string, limit = 10) {
+  return comicVineFetch<import('./types').ComicVineIssue[]>('/search/', {
+    query,
+    resources: 'issue',
+    limit: String(limit),
+    field_list: FIELD_LIST_ISSUE,
+  })
+}
+
+export async function searchComicVineVolumes(query: string, limit = 10) {
+  return comicVineFetch<import('./types').ComicVineVolume[]>('/search/', {
+    query,
+    resources: 'volume',
+    limit: String(limit),
+    field_list: FIELD_LIST_VOLUME,
+  })
+}
+
+export async function fetchComicVineIssue(id: string) {
+  return comicVineFetch<import('./types').ComicVineIssue>(`/issue/4000-${id}/`, {
+    field_list: FIELD_LIST_ISSUE,
+  })
+}
+
+export async function fetchComicVineVolume(id: string) {
+  return comicVineFetch<import('./types').ComicVineVolume>(`/volume/4050-${id}/`, {
+    field_list: FIELD_LIST_VOLUME,
+  })
+}

package/layers/metadata-comicvine/server/utils/metadata-comicvine/normalise.ts

@@ -0,0 +1,55 @@
+import type { MetadataRecord, MetadataCreator } from '#layers/metadata/shared/types'
+import type { ComicVineIssue, ComicVineVolume } from './types'
+
+// fallow-ignore-next-line complexity
+export function normaliseComicVineIssue(issue: ComicVineIssue): MetadataRecord {
+  const creators: MetadataCreator[] = (issue.person_credits ?? []).map((p) => ({
+    name: p.name,
+    role: p.role,
+    providerId: String(p.id),
+  }))
+
+  return {
+    id: `comicvine:issue:${issue.id}`,
+    provider: 'comicvine',
+    providerId: String(issue.id),
+    mediaType: 'comic',
+    title: issue.volume?.name ? `${issue.volume.name} #${issue.issue_number}` : (issue.name ?? `Issue #${issue.issue_number}`),
+    subtitle: issue.name ?? undefined,
+    description: issue.deck ?? issue.description ?? undefined,
+    creators: creators.length ? creators : undefined,
+    publisher: issue.publisher?.name ?? undefined,
+    publishedAt: issue.cover_date ?? issue.store_date ?? undefined,
+    coverUrl: issue.image?.medium_url ?? issue.image?.original_url ?? undefined,
+    identifiers: { comicVineId: String(issue.id) },
+    sourceUrl: issue.site_detail_url,
+    raw: issue,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}
+
+// fallow-ignore-next-line complexity
+export function normaliseComicVineVolume(volume: ComicVineVolume): MetadataRecord {
+  const creators: MetadataCreator[] = (volume.people ?? []).map((p) => ({
+    name: p.name,
+    role: p.role,
+    providerId: String(p.id),
+  }))
+
+  return {
+    id: `comicvine:volume:${volume.id}`,
+    provider: 'comicvine',
+    providerId: String(volume.id),
+    mediaType: 'comic',
+    title: volume.name,
+    description: volume.deck ?? volume.description ?? undefined,
+    creators: creators.length ? creators : undefined,
+    publisher: volume.publisher?.name ?? undefined,
+    publishedAt: volume.start_year ?? undefined,
+    coverUrl: volume.image?.medium_url ?? volume.image?.original_url ?? undefined,
+    identifiers: { comicVineId: String(volume.id) },
+    sourceUrl: volume.site_detail_url,
+    raw: volume,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}

package/layers/metadata-comicvine/server/utils/metadata-comicvine/provider.ts

@@ -0,0 +1,39 @@
+import type { MetadataProvider } from '#layers/metadata/shared/types'
+
+export const comicVineProvider: MetadataProvider = {
+  id: 'comicvine',
+  label: 'Comic Vine',
+  mediaTypes: ['comic', 'graphic-novel', 'collected-edition'],
+
+  // fallow-ignore-next-line complexity
+  async search({ query, mediaType, limit = 10 }) {
+    const resourceType = mediaType === 'collected-edition' || mediaType === 'graphic-novel' ? 'volume' : 'issue'
+
+    if (resourceType === 'volume') {
+      const res = await searchComicVineVolumes(query, limit)
+      return (Array.isArray(res.results) ? res.results : []).map(normaliseComicVineVolume)
+    }
+
+    const [issueRes, volumeRes] = await Promise.all([
+      searchComicVineIssues(query, Math.ceil(limit / 2)),
+      searchComicVineVolumes(query, Math.floor(limit / 2)),
+    ])
+
+    const issues = (Array.isArray(issueRes.results) ? issueRes.results : []).map(normaliseComicVineIssue)
+    const volumes = (Array.isArray(volumeRes.results) ? volumeRes.results : []).map(normaliseComicVineVolume)
+    return [...issues, ...volumes]
+  },
+
+  async lookup({ providerId, resourceType = 'issue' }) {
+    if (resourceType === 'volume') {
+      const res = await fetchComicVineVolume(providerId)
+      return normaliseComicVineVolume(res.results as import('./types').ComicVineVolume)
+    }
+    const res = await fetchComicVineIssue(providerId)
+    return normaliseComicVineIssue(res.results as import('./types').ComicVineIssue)
+  },
+
+  async sync({ providerId, resourceType = 'issue' }) {
+    return (await comicVineProvider.lookup!({ provider: 'comicvine', providerId, resourceType }))!
+  },
+}

package/layers/metadata-comicvine/server/utils/metadata-comicvine/types.ts

@@ -0,0 +1,36 @@
+export type ComicVineApiResponse<T> = {
+  error: string
+  limit: number
+  offset: number
+  number_of_page_results: number
+  number_of_total_results: number
+  status_code: number
+  results: T
+}
+
+export type ComicVineIssue = {
+  id: number
+  name: string | null
+  issue_number: string
+  description: string | null
+  deck: string | null
+  cover_date: string | null
+  store_date: string | null
+  site_detail_url: string
+  image: { original_url: string; medium_url: string } | null
+  volume: { id: number; name: string } | null
+  person_credits: Array<{ id: number; name: string; role: string }> | null
+  publisher: { id: number; name: string } | null
+}
+
+export type ComicVineVolume = {
+  id: number
+  name: string
+  description: string | null
+  deck: string | null
+  start_year: string | null
+  site_detail_url: string
+  image: { original_url: string; medium_url: string } | null
+  publisher: { id: number; name: string } | null
+  people: Array<{ id: number; name: string; role: string }> | null
+}

package/layers/metadata-comicvine/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../apps/playground/tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

package/layers/metadata-google-books/nuxt.config.ts

@@ -0,0 +1,32 @@
+export default defineNuxtConfig({
+  $meta: {
+    name: 'metadata-google-books',
+  },
+
+  extends: ['../metadata'],
+
+  alias: {
+    '#layers/metadata-google-books': import.meta.dirname,
+  },
+
+  compatibilityDate: '2026-06-30',
+
+  runtimeConfig: {
+    metadataGoogleBooks: {
+      apiKey: '', // env: NUXT_METADATA_GOOGLE_BOOKS_API_KEY (optional — anonymous quota is limited)
+    },
+  },
+
+  typescript: {
+    typeCheck: false,
+    strict: true,
+  },
+})
+
+declare module '@nuxt/schema' {
+  interface RuntimeConfig {
+    metadataGoogleBooks: {
+      apiKey: string
+    }
+  }
+}

package/layers/metadata-google-books/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "kmcom-layer-metadata-google-books",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "dev": "nuxi dev",
+    "dev:playground": "PLAYGROUND_LAYERS=core,metadata,metadata-google-books pnpm -F playground dev",
+    "typecheck": "vue-tsc --noEmit -p ../../tsconfig.typecheck.json",
+    "lint": "eslint ."
+  }
+}

package/layers/metadata-google-books/server/plugins/google-books-register.ts

@@ -0,0 +1,3 @@
+export default defineNitroPlugin(() => {
+  registerProvider(googleBooksProvider)
+})

package/layers/metadata-google-books/server/utils/metadata-google-books/client.ts

@@ -0,0 +1,23 @@
+import type { GoogleBooksSearchResponse, GoogleBooksVolume } from './types'
+
+const BASE = 'https://www.googleapis.com/books/v1'
+
+function getApiKey(): string | undefined {
+  return useRuntimeConfig().metadataGoogleBooks?.apiKey || undefined
+}
+
+export async function searchGoogleBooks(query: string, limit = 10): Promise<GoogleBooksSearchResponse> {
+  const params: Record<string, string> = { q: query, maxResults: String(limit) }
+  const apiKey = getApiKey()
+  if (apiKey) params.key = apiKey
+
+  return $fetch<GoogleBooksSearchResponse>(`${BASE}/volumes`, { query: params })
+}
+
+export async function fetchGoogleBooksVolume(id: string): Promise<GoogleBooksVolume> {
+  const params: Record<string, string> = {}
+  const apiKey = getApiKey()
+  if (apiKey) params.key = apiKey
+
+  return $fetch<GoogleBooksVolume>(`${BASE}/volumes/${id}`, { query: params })
+}

package/layers/metadata-google-books/server/utils/metadata-google-books/normalise.ts

@@ -0,0 +1,39 @@
+import type { MetadataRecord, MetadataCreator } from '#layers/metadata/shared/types'
+import type { GoogleBooksVolume } from './types'
+
+// fallow-ignore-next-line complexity
+export function normaliseGoogleBooksVolume(volume: GoogleBooksVolume): MetadataRecord {
+  const { volumeInfo } = volume
+
+  const creators: MetadataCreator[] = (volumeInfo.authors ?? []).map((name) => ({
+    name,
+    role: 'author',
+  }))
+
+  const isbn10 = volumeInfo.industryIdentifiers?.find((i) => i.type === 'ISBN_10')?.identifier
+  const isbn13 = volumeInfo.industryIdentifiers?.find((i) => i.type === 'ISBN_13')?.identifier
+
+  const cover = volumeInfo.imageLinks?.thumbnail ?? volumeInfo.imageLinks?.smallThumbnail
+
+  return {
+    id: `google-books:volume:${volume.id}`,
+    provider: 'google-books',
+    providerId: volume.id,
+    mediaType: 'book',
+    title: volumeInfo.title,
+    subtitle: volumeInfo.subtitle,
+    description: volumeInfo.description,
+    creators: creators.length ? creators : undefined,
+    publisher: volumeInfo.publisher,
+    publishedAt: volumeInfo.publishedDate,
+    coverUrl: cover ? cover.replace('http://', 'https://') : undefined,
+    identifiers: {
+      isbn10,
+      isbn13,
+      googleBooksId: volume.id,
+    },
+    sourceUrl: volumeInfo.canonicalVolumeLink ?? volumeInfo.infoLink,
+    raw: volume,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}

package/layers/metadata-google-books/server/utils/metadata-google-books/provider.ts

@@ -0,0 +1,21 @@
+import type { MetadataProvider } from '#layers/metadata/shared/types'
+
+export const googleBooksProvider: MetadataProvider = {
+  id: 'google-books',
+  label: 'Google Books',
+  mediaTypes: ['book', 'graphic-novel', 'collected-edition'],
+
+  async search({ query, limit = 10 }) {
+    const res = await searchGoogleBooks(query, limit)
+    return (res.items ?? []).map(normaliseGoogleBooksVolume)
+  },
+
+  async lookup({ providerId }) {
+    const volume = await fetchGoogleBooksVolume(providerId)
+    return normaliseGoogleBooksVolume(volume)
+  },
+
+  async sync({ providerId }) {
+    return (await googleBooksProvider.lookup!({ provider: 'google-books', providerId }))!
+  },
+}

package/layers/metadata-google-books/server/utils/metadata-google-books/types.ts

@@ -0,0 +1,25 @@
+export type GoogleBooksVolumeInfo = {
+  title: string
+  subtitle?: string
+  authors?: string[]
+  publisher?: string
+  publishedDate?: string
+  description?: string
+  industryIdentifiers?: Array<{ type: 'ISBN_10' | 'ISBN_13' | string; identifier: string }>
+  pageCount?: number
+  imageLinks?: { thumbnail?: string; smallThumbnail?: string }
+  previewLink?: string
+  infoLink?: string
+  canonicalVolumeLink?: string
+}
+
+export type GoogleBooksVolume = {
+  id: string
+  selfLink: string
+  volumeInfo: GoogleBooksVolumeInfo
+}
+
+export type GoogleBooksSearchResponse = {
+  totalItems: number
+  items?: GoogleBooksVolume[]
+}

package/layers/metadata-google-books/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../apps/playground/tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

package/layers/metadata-openlibrary/nuxt.config.ts

@@ -0,0 +1,18 @@
+export default defineNuxtConfig({
+  $meta: {
+    name: 'metadata-openlibrary',
+  },
+
+  extends: ['../metadata'],
+
+  alias: {
+    '#layers/metadata-openlibrary': import.meta.dirname,
+  },
+
+  compatibilityDate: '2026-06-30',
+
+  typescript: {
+    typeCheck: false,
+    strict: true,
+  },
+})

package/layers/metadata-openlibrary/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "kmcom-layer-metadata-openlibrary",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "dev": "nuxi dev",
+    "dev:playground": "PLAYGROUND_LAYERS=core,metadata,metadata-openlibrary pnpm -F playground dev",
+    "typecheck": "vue-tsc --noEmit -p ../../tsconfig.typecheck.json",
+    "lint": "eslint ."
+  }
+}

package/layers/metadata-openlibrary/server/plugins/openlibrary-register.ts

@@ -0,0 +1,3 @@
+export default defineNitroPlugin(() => {
+  registerProvider(openLibraryProvider)
+})

package/layers/metadata-openlibrary/server/utils/metadata-openlibrary/client.ts

@@ -0,0 +1,30 @@
+import type { OpenLibrarySearchResponse, OpenLibraryWork, OpenLibraryEdition } from './types'
+
+const BASE = 'https://openlibrary.org'
+
+export function openLibraryCoverUrl(coverId: number, size: 'S' | 'M' | 'L' = 'M'): string {
+  return `https://covers.openlibrary.org/b/id/${coverId}-${size}.jpg`
+}
+
+export async function searchOpenLibrary(query: string, limit = 10): Promise<OpenLibrarySearchResponse> {
+  return $fetch<OpenLibrarySearchResponse>(`${BASE}/search.json`, {
+    query: { q: query, limit, fields: 'key,title,subtitle,author_name,author_key,publisher,first_publish_year,isbn,cover_i,number_of_pages_median' },
+  })
+}
+
+export async function lookupOpenLibraryWork(workId: string): Promise<OpenLibraryWork> {
+  return $fetch<OpenLibraryWork>(`${BASE}/works/${workId}.json`)
+}
+
+export async function lookupOpenLibraryEdition(editionId: string): Promise<OpenLibraryEdition> {
+  return $fetch<OpenLibraryEdition>(`${BASE}/books/${editionId}.json`)
+}
+
+export async function lookupByIsbn(isbn: string): Promise<OpenLibraryEdition | null> {
+  try {
+    return await $fetch<OpenLibraryEdition>(`${BASE}/isbn/${isbn}.json`)
+  }
+  catch {
+    return null
+  }
+}

package/layers/metadata-openlibrary/server/utils/metadata-openlibrary/normalise.ts

@@ -0,0 +1,81 @@
+import type { MetadataRecord, MetadataCreator } from '#layers/metadata/shared/types'
+import type { OpenLibrarySearchDoc, OpenLibraryWork, OpenLibraryEdition } from './types'
+
+// fallow-ignore-next-line complexity
+export function normaliseOpenLibrarySearchDoc(doc: OpenLibrarySearchDoc): MetadataRecord {
+  const creators: MetadataCreator[] = (doc.author_name ?? []).map((name, i) => ({
+    name,
+    role: 'author',
+    providerId: doc.author_key?.[i]?.replace('/authors/', '') ?? undefined,
+  }))
+
+  const id = doc.key.replace('/works/', '')
+
+  return {
+    id: `openlibrary:work:${id}`,
+    provider: 'openlibrary',
+    providerId: id,
+    mediaType: 'book',
+    title: doc.title,
+    subtitle: doc.subtitle,
+    creators: creators.length ? creators : undefined,
+    publisher: doc.publisher?.[0] ?? undefined,
+    publishedAt: doc.first_publish_year ? String(doc.first_publish_year) : undefined,
+    coverUrl: doc.cover_i ? openLibraryCoverUrl(doc.cover_i) : undefined,
+    identifiers: {
+      isbn10: doc.isbn?.find((i) => i.length === 10),
+      isbn13: doc.isbn?.find((i) => i.length === 13),
+      openLibraryId: id,
+    },
+    sourceUrl: `https://openlibrary.org${doc.key}`,
+    raw: doc,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}
+
+// fallow-ignore-next-line complexity
+export function normaliseOpenLibraryWork(work: OpenLibraryWork): MetadataRecord {
+  const id = work.key.replace('/works/', '')
+  const desc = typeof work.description === 'string' ? work.description : work.description?.value
+
+  return {
+    id: `openlibrary:work:${id}`,
+    provider: 'openlibrary',
+    providerId: id,
+    mediaType: 'book',
+    title: work.title,
+    subtitle: work.subtitle,
+    description: desc,
+    coverUrl: work.covers?.[0] ? openLibraryCoverUrl(work.covers[0]) : undefined,
+    publishedAt: work.first_publish_date,
+    identifiers: { openLibraryId: id },
+    sourceUrl: `https://openlibrary.org${work.key}`,
+    raw: work,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}
+
+// fallow-ignore-next-line complexity
+export function normaliseOpenLibraryEdition(edition: OpenLibraryEdition): MetadataRecord {
+  const id = edition.key.replace('/books/', '')
+
+  return {
+    id: `openlibrary:edition:${id}`,
+    provider: 'openlibrary',
+    providerId: id,
+    mediaType: 'book',
+    title: edition.title,
+    subtitle: edition.subtitle,
+    publisher: edition.publishers?.[0] ?? undefined,
+    publishedAt: edition.publish_date,
+    coverUrl: edition.covers?.[0] ? openLibraryCoverUrl(edition.covers[0]) : undefined,
+    identifiers: {
+      isbn10: edition.isbn_10?.[0],
+      isbn13: edition.isbn_13?.[0],
+      openLibraryId: id,
+    },
+    sourceUrl: `https://openlibrary.org${edition.key}`,
+    raw: edition,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}

package/layers/metadata-openlibrary/server/utils/metadata-openlibrary/provider.ts

@@ -0,0 +1,25 @@
+import type { MetadataProvider } from '#layers/metadata/shared/types'
+
+export const openLibraryProvider: MetadataProvider = {
+  id: 'openlibrary',
+  label: 'Open Library',
+  mediaTypes: ['book', 'graphic-novel', 'collected-edition'],
+
+  async search({ query, limit = 10 }) {
+    const res = await searchOpenLibrary(query, limit)
+    return res.docs.map(normaliseOpenLibrarySearchDoc)
+  },
+
+  async lookup({ providerId, resourceType = 'work' }) {
+    if (resourceType === 'edition') {
+      const edition = await lookupOpenLibraryEdition(providerId)
+      return normaliseOpenLibraryEdition(edition)
+    }
+    const work = await lookupOpenLibraryWork(providerId)
+    return normaliseOpenLibraryWork(work)
+  },
+
+  async sync({ providerId, resourceType = 'work' }) {
+    return (await openLibraryProvider.lookup!({ provider: 'openlibrary', providerId, resourceType }))!
+  },
+}

package/layers/metadata-openlibrary/server/utils/metadata-openlibrary/types.ts

@@ -0,0 +1,48 @@
+export type OpenLibrarySearchDoc = {
+  key: string
+  title: string
+  subtitle?: string
+  author_name?: string[]
+  author_key?: string[]
+  publisher?: string[]
+  first_publish_year?: number
+  isbn?: string[]
+  cover_i?: number
+  number_of_pages_median?: number
+  language?: string[]
+}
+
+export type OpenLibrarySearchResponse = {
+  numFound: number
+  docs: OpenLibrarySearchDoc[]
+}
+
+export type OpenLibraryWork = {
+  key: string
+  title: string
+  subtitle?: string
+  description?: { value: string } | string
+  authors?: Array<{ author: { key: string }; type: { key: string } }>
+  first_publish_date?: string
+  covers?: number[]
+  subjects?: string[]
+}
+
+export type OpenLibraryEdition = {
+  key: string
+  title: string
+  subtitle?: string
+  publishers?: string[]
+  publish_date?: string
+  isbn_13?: string[]
+  isbn_10?: string[]
+  covers?: number[]
+  works?: Array<{ key: string }>
+  number_of_pages?: number
+}
+
+export type OpenLibraryAuthor = {
+  key: string
+  name: string
+  personal_name?: string
+}

package/layers/metadata-openlibrary/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../apps/playground/tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kmcom-nuxt-layers",
   "private": false,
-  "version": "2.3.2",
+  "version": "2.5.0",
   "description": "Composable Nuxt 4 layers for building scalable Vue applications",
   "exports": {
     "./layers/core": "./layers/core/nuxt.config.ts",
@@ -21,11 +21,17 @@
     "./layers/shader": "./layers/shader/nuxt.config.ts",
     "./layers/mailer": "./layers/mailer/nuxt.config.ts",
     "./layers/forms": "./layers/forms/nuxt.config.ts",
+    "./layers/database": "./layers/database/nuxt.config.ts",
+    "./layers/auth": "./layers/auth/nuxt.config.ts",
     "./layers/theme": "./layers/theme/nuxt.config.ts",
     "./layers/content": "./layers/content/nuxt.config.ts",
     "./layers/feeds": "./layers/feeds/nuxt.config.ts",
     "./layers/routing": "./layers/routing/nuxt.config.ts",
-    "./layers/starter": "./layers/starter/nuxt.config.ts"
+    "./layers/starter": "./layers/starter/nuxt.config.ts",
+    "./layers/metadata": "./layers/metadata/nuxt.config.ts",
+    "./layers/metadata-comicvine": "./layers/metadata-comicvine/nuxt.config.ts",
+    "./layers/metadata-openlibrary": "./layers/metadata-openlibrary/nuxt.config.ts",
+    "./layers/metadata-google-books": "./layers/metadata-google-books/nuxt.config.ts"
   },
   "files": [
     "layers/*/nuxt.config.ts",
@@ -159,6 +165,7 @@
     "@webgpu/glslang": "^0.0.15",
     "@webgpu/types": "^0.1.70",
     "browserslist": "^4.28.2",
+    "browserslist-config-baseline": "^0.5.0",
     "changesets": "^1.0.2",
     "csstype": "^3.2.3",
     "cypress": "^15.16.0",
@@ -207,7 +214,7 @@
     "last 2 Firefox major versions",
     "last 2 Safari major versions",
     "last 2 Edge major versions",
-    "baseline widely available"
+    "extends browserslist-config-baseline"
   ],
   "dependencies": {
     "node-gyp": "^12.3.0",
@@ -228,6 +235,8 @@
     "dev:ui": "PLAYGROUND_LAYERS=core,ui pnpm -F playground dev",
     "dev:layout": "PLAYGROUND_LAYERS=core,ui,layout pnpm -F playground dev",
     "dev:motion": "PLAYGROUND_LAYERS=core,motion pnpm -F playground dev",
+    "dev:database": "PLAYGROUND_LAYERS=core,database pnpm -F playground dev",
+    "dev:auth": "PLAYGROUND_LAYERS=core,auth pnpm -F playground dev",
     "build": "turbo run build",
     "lint": "turbo run lint",
     "lint:fix": "turbo run lint -- --fix",

package/types/auth.ts

@@ -0,0 +1,7 @@
+// fallow-ignore-next-line unused-type
+export type SessionUser = {
+  provider: 'github'
+  providerId: string
+  username: string
+  avatarUrl?: string
+}

package/types/index.ts

@@ -17,3 +17,5 @@ export type {
 export type { ScrollLockEvent, LoadingStateEvent, LayerEvent } from './events'
 export type { MotionConfig, TransitionConfig } from './motion'
 export type { PublicRuntimeConfig } from './runtime'
+// fallow-ignore-next-line unused-type
+export type { SessionUser } from './auth'