AI-native design editor. Open-source Figma alternative.
import { mkdir, readFile } from 'node:fs/promises'
import { dirname, resolve, sep } from 'node:path'
import * as v from 'valibot'
import type {
ComponentLibraryRevision,
LibraryCatalog,
LibrarySummary,
PublishLibraryInput,
StoredLibraryLatestManifest
} from '@open-pencil/core/library'
import {
createLibraryRevision,
deserializeLibraryRevision,
encodeStoredLibraryRevision,
librarySummarySchema,
MAX_LIBRARY_REVISION_BYTES,
storedLibraryLatestManifestSchema,
storedLibraryRevisionSchema,
validateLibraryRevision
} from '@open-pencil/core/library'
import { writeFileAtomic } from '@open-pencil/core/node/fs'
const catalogPublicationQueues = new Map<string, Promise<void>>()
async function serializePublication<T>(root: string, operation: () => Promise<T>): Promise<T> {
const previous = catalogPublicationQueues.get(root) ?? Promise.resolve()
let release: (() => void) | undefined
const current = new Promise<void>((resolveQueue) => {
release = resolveQueue
})
const tail = previous.then(() => current)
catalogPublicationQueues.set(root, tail)
await previous
try {
return await operation()
} finally {
release?.()
if (catalogPublicationQueues.get(root) === tail) catalogPublicationQueues.delete(root)
}
}
export class FileSystemLibraryCatalog implements LibraryCatalog {
readonly #root: string
constructor(root: string) {
this.#root = resolve(root)
}
async listLibraries(): Promise<LibrarySummary[]> {
try {
return await this.#readJSON('libraries.json', v.array(librarySummarySchema))
} catch (error) {
if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return []
throw error
}
}
async getRevision(libraryId: string, revisionId?: string): Promise<ComponentLibraryRevision> {
const resolvedRevisionId =
revisionId ??
(await this.#readJSON(`${libraryId}/manifest.json`, storedLibraryLatestManifestSchema))
.summary.latestRevisionId
const data = await this.#readJSON(
`${libraryId}/revisions/${resolvedRevisionId}.json`,
storedLibraryRevisionSchema,
MAX_LIBRARY_REVISION_BYTES
)
const revision = deserializeLibraryRevision(data)
if (
revision.manifest.libraryId !== libraryId ||
revision.manifest.revisionId !== resolvedRevisionId
) {
throw new Error('Library revision identity mismatch')
}
await validateLibraryRevision(revision)
return revision
}
async publishRevision(input: PublishLibraryInput): Promise<ComponentLibraryRevision> {
return serializePublication(this.#root, async () => {
const current = (await this.listLibraries()).find(
(item) => item.libraryId === input.libraryId
)
if ((input.previousRevisionId ?? null) !== (current?.latestRevisionId ?? null)) {
throw new Error('Library revision conflict: latest revision has changed')
}
const revision = await createLibraryRevision(input)
const manifest = revision.manifest
await this.#writeJSON(
`${manifest.libraryId}/revisions/${manifest.revisionId}.json`,
encodeStoredLibraryRevision(revision)
)
const summary: LibrarySummary = {
libraryId: manifest.libraryId,
name: manifest.name,
latestRevisionId: manifest.revisionId,
publishedAt: manifest.publishedAt,
assetCount: manifest.assets.length
}
await this.#writeJSON(`${manifest.libraryId}/manifest.json`, {
schemaVersion: 1,
summary
} satisfies StoredLibraryLatestManifest)
const summaries = (await this.listLibraries()).filter(
(item) => item.libraryId !== input.libraryId
)
summaries.push(summary)
await this.#writeJSON(
'libraries.json',
summaries.sort((left, right) => left.name.localeCompare(right.name))
)
return revision
})
}
#path(relative: string): string {
if (relative.split(/[\\/]/).some((segment) => segment === '..'))
throw new Error('Invalid catalog path')
const path = resolve(this.#root, relative)
if (path !== this.#root && !path.startsWith(`${this.#root}${sep}`))
throw new Error('Invalid catalog path')
return path
}
async #readJSON<TSchema extends v.GenericSchema>(
relative: string,
schema: TSchema,
maxBytes = Number.POSITIVE_INFINITY
): Promise<v.InferOutput<TSchema>> {
const bytes = await readFile(this.#path(relative))
if (bytes.byteLength > maxBytes)
throw new Error(`Library catalog file exceeds size limit: ${relative}`)
const text = new TextDecoder().decode(bytes)
const result = v.safeParse(v.pipe(v.string(), v.parseJson(), schema), text)
if (!result.success)
throw new Error(`Invalid library catalog file ${relative}: ${v.summarize(result.issues)}`)
return result.output
}
async #writeJSON(relative: string, value: unknown): Promise<void> {
const path = this.#path(relative)
await mkdir(dirname(path), { recursive: true })
await writeFileAtomic(path, JSON.stringify(value, null, 2))
}
}