@alinea/backend

export class Backend<T extends Workspaces = Workspaces> implements Hub<T>

{

constructor<T extends Workspaces = Workspaces>(

options: BackendOptions<T>

): Backend<T>

config: Config<T>

createStore:

{}

options: BackendOptions<T>

preview: PreviewStore

get drafts(): Drafts

deleteDraft(

id: string

): Future<boolean>

entry(

id: string,

stateVector: Uint8Array

): Future<null | Detail>

listDrafts(

workspace: string

): Promise<Outcome<Array<{id: string}>>>

loadPages<K extends string | number | symbol>(

workspaceKey: K,

previewToken: string

): Pages<T[K] extends WorkspaceConfig<W> ? W : any>

parsePreviewToken(

token: string

): Promise<{id: string, url: string}>

publishEntries(

entries: Array<Entry>

): Future<void>

query<T>(

cursor: Cursor<T>,

options: QueryOptions

): Future<Array<T>>

updateDraft(

id: string,

update: Uint8Array

): Future<void>

uploadFile(

workspace: string,

root: string,

file: Upload

): Future<File>

}

export type BackendOptions<T extends Workspaces>

{

config: Config<T>

drafts: Drafts

media: Data.Media

previews: Previews

target: Data.Target

createStore(): Promise<Store>

}

export namespace Cache {

export function applyPublish(

store: Store,

config: Config<Workspaces>,

entries: Array<Entry>

): void

export function applyUpdates(

store: Store,

config: Config<Workspaces>,

updates: IterableIterator<[string, Uint8Array]>

): void

export function computeEntry(

store: Store,

config: Config<Workspaces>,

entry: Entry

): {$isContainer: undefined | boolean, $status: EntryStatus, i18n: I18N, id: string, index: string, parent: string, parents: Array<string>, path: string, root: string, title: Label, type: string, url: string, workspace: string}

export function create(

store: SqliteStore,

config: Config<Workspaces>,

from: Source,

log: boolean

): Promise<void>

}

export function createServer<T extends Workspaces>(

options: ServerOptions<T>

): Server<T>

export namespace Data {

export namespace Media {

export type Download

| {buffer: ArrayBuffer, type: "buffer"}

| {type: "url", url: string}

export type Upload

{

buffer: ArrayBuffer

color: string

path: string

preview: string

}

export namespace Source {

export function concat(

sources: Array<Source>

): Source

}

export interface Media

{

download(

workspace: string,

location: string

): Promise<Download>

upload(

workspace: string,

file: Upload

): Promise<string>

}

export interface Source

{

entries(): AsyncGenerator<Entry, any, unknown>

watchFiles(): Promise<Array<string>>

}

export interface Target

{

publish(

current: Store,

entries: Array<Entry>

): Promise<void>

}

export class DevServer<T extends Workspaces = Workspaces> extends Server<T>

{

constructor<T extends Workspaces = Workspaces>(

props: DevServerOptions<T>

): DevServer<T>

app: Express

config: Config<T>

createStore:

{}

options: ServerOptions<T>

preview: PreviewStore

get drafts(): Drafts

deleteDraft(

id: string

): Future<boolean>

entry(

id: string,

stateVector: Uint8Array

): Future<null | Detail>

listDrafts(

workspace: string

): Promise<Outcome<Array<{id: string}>>>

listen(

port: number

): Server

loadPages<K extends string | number | symbol>(

workspaceKey: K,

previewToken: string

): Pages<T[K] extends WorkspaceConfig<W> ? W : any>

parsePreviewToken(

token: string

): Promise<{id: string, url: string}>

publishEntries(

entries: Array<Entry>

): Future<void>

query<T>(

cursor: Cursor<T>,

options: QueryOptions

): Future<Array<T>>

respond(

req: IncomingMessage,

res: ServerResponse

): Promise<void>

updateDraft(

id: string,

update: Uint8Array

): Future<void>

uploadFile(

workspace: string,

root: string,

file: Upload

): Future<File>

}

export interface DevServerOptions<T extends Workspaces>

{

config: Config<T>

cwd: string

port: number

createStore(): Promise<Store>

}

export namespace Drafts {

export type Update

{

id: string

update: Uint8Array

}

export interface Drafts

{

delete(

ids: Array<string>

): Promise<void>

get(

id: string,

stateVector: Uint8Array

): Promise<undefined | Uint8Array>

update(

id: string,

update: Uint8Array

): Promise<Update>

updates(): AsyncGenerator<Update, any, unknown>

}

export class FileData implements Source, Target, Media

{

constructor(

options: FileDataOptions

): FileData

options: FileDataOptions

download(

workspace: string,

location: string

): Promise<Download>

entries(): AsyncGenerator<Entry, any, unknown>

publish(

current: Store,

entries: Array<Entry>

): Promise<void>

upload(

workspace: string,

file: Upload

): Promise<string>

watchFiles(): Promise<Array<string>>

}

export type FileDataOptions

{

config: Config

fs: FS

loader: Loader

rootDir: string

}

export class FileDrafts implements Drafts

{

constructor(

options: FileDraftsOptions

): FileDrafts

options: FileDraftsOptions

delete(

ids: Array<string>

): Promise<void>

get(

id: string,

stateVector: Uint8Array

): Promise<undefined | Uint8Array>

update(

id: string,

update: Uint8Array

): Promise<Update>

updates(): AsyncGenerator<{id: string, update: Uint8Array}, any, unknown>

}

export type FileDraftsOptions

{

dir: string

fs: FS

}

export type FS

= Omit<__module, NotIncluded>

export class GithubData implements Target, Media

{

constructor(

options: GithubTargetOptions

): GithubData

octokit: Octokit &

{

paginate: PaginateInterface

}

& RestEndpointMethods & Api

options: GithubTargetOptions

download(

workspace: string,

location: string

): Promise<Download>

publish(

current: Store,

entries: Array<Entry>

): Promise<void>

upload(

workspace: string,

file: Upload

): Promise<string>

}

export type GithubTargetOptions

{

author:

{

email: string

name: string

}

branch: string

config: Config

githubAuthToken: string

loader: Loader

owner: string

repo: string

rootDir: string

}

export class IndexedDBData implements Source, Target, Media

{

constructor(

options: IndexedDBOptions

): IndexedDBData

db: Promise<IDBDatabase>

options: IndexedDBOptions

download(

workspace: string,

location: string

): Promise<Download>

entries(): AsyncGenerator<Entry, any, unknown>

publish(

current: Store,

entries: Array<Entry>

): Promise<void>

upload(

workspace: string,

file: Upload

): Promise<string>

}

export class IndexedDBDrafts implements Drafts

{

constructor(

options: IndexedDBOptions

): IndexedDBDrafts

db: Promise<IDBDatabase>

options: IndexedDBOptions

delete(

ids: Array<string>

): Promise<void>

get(

id: string,

stateVector: Uint8Array

): Promise<undefined | Uint8Array>

update(

id: string,

update: Uint8Array

): Promise<Update>

updates(): AsyncGenerator<Update, any, unknown>

}

export type IndexedDBOptions

{}

export type IndexedDBOptions

{}

export const JsonLoader: Loader

export class JWTPreviews implements Previews

{

constructor(

secret: string

): JWTPreviews

sign(

data: {id: string}

): string

verify(

token: string

): {id: string}

}

export type Page<P, T>

= T extends {id: string}

? T &

{

tree: PageTree

}

: T

export type Pages<T>

= PagesImpl<T> &

export const Pages: PagesConstructor

export interface PagesConstructor

{

constructor<T>(

workspace: Workspace<T>,

createCache: {}

): Pages<T>

}

export class PageTree

{

constructor(

resolver: PageResolver,

id: EV<string>

): PageTree

get root(): Multiple<P, P>

children<Child>(

depth: number

): Multiple<P, Child>

nextSibling(): Single<P, P>

parent<Parent>(): Single<P, Parent>

parents<Parent>(): Multiple<P, Parent>

prevSibling(): Single<P, P>

siblings(): Multiple<P, P>

}

export function parseBuffer(

req: IncomingMessage,

options: ParseOptions

): Promise<Buffer | string>

export function parseJson(

req: IncomingMessage,

options: ParseOptions

): Promise<any>

export function parseText(

req: IncomingMessage,

options: ParseOptions

): Promise<any>

export class RedisDrafts implements Drafts

{

constructor(

options: RedisDraftsOptions

): RedisDrafts

options: RedisDraftsOptions

delete(

ids: Array<string>

): Promise<void>

get(

id: string,

stateVector: Uint8Array

): Promise<undefined | Uint8Array>

update(

id: string,

update: Uint8Array

): Promise<Update>

updates(): AsyncGenerator<Update, any, unknown>

}

export type RedisDraftsOptions

{

client: Redis

prefix: string

}

export class Server<T extends Workspaces = Workspaces> extends Backend<T>

{

constructor<T extends Workspaces = Workspaces>(

options: ServerOptions<T>

): Server<T>

app: Express

config: Config<T>

createStore:

{}

options: ServerOptions<T>

preview: PreviewStore

get drafts(): Drafts

deleteDraft(

id: string

): Future<boolean>

entry(

id: string,

stateVector: Uint8Array

): Future<null | Detail>

listDrafts(

workspace: string

): Promise<Outcome<Array<{id: string}>>>

listen(

port: number

): Server

loadPages<K extends string | number | symbol>(

workspaceKey: K,

previewToken: string

): Pages<T[K] extends WorkspaceConfig<W> ? W : any>

parsePreviewToken(

token: string

): Promise<{id: string, url: string}>

publishEntries(

entries: Array<Entry>

): Future<void>

query<T>(

cursor: Cursor<T>,

options: QueryOptions

): Future<Array<T>>

respond(

req: IncomingMessage,

res: ServerResponse

): Promise<void>

updateDraft(

id: string,

update: Uint8Array

): Future<void>

uploadFile(

workspace: string,

root: string,

file: Upload

): Future<File>

}

export type ServerOptions<T extends Workspaces>

{

auth: Auth.Server

dashboardUrl: string

}

& BackendOptions<T>