akanjs 2.2.4 → 2.2.5

package/types/service/predefinedAdaptor/database.adaptor.d.ts

@@ -0,0 +1,329 @@
+import { Database } from "bun:sqlite";
+import type { Client as LibsqlClient } from "@libsql/client";
+import { type BaseEnv, type PromiseOrObject } from "akanjs/base";
+import { type ConstantModel } from "akanjs/constant";
+import { type DatabaseModel, type DocumentQuery, type DocumentSchema, type DocumentUpdate, type DocumentUpdateOptions, type SchemaOf } from "akanjs/document";
+import type { Sql } from "postgres";
+export interface SqliteDatabaseConfig {
+    filePath?: string;
+    journalMode?: "WAL" | "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY" | "OFF";
+    busyTimeoutMs?: number;
+    synchronous?: "OFF" | "NORMAL" | "FULL" | "EXTRA";
+    foreignKeys?: boolean;
+    cacheSize?: number;
+    tempStore?: "DEFAULT" | "FILE" | "MEMORY";
+}
+export interface LibsqlDatabaseConfig {
+    url?: string;
+    authToken?: string;
+}
+export interface PostgresDatabaseConfig {
+    url?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+}
+export interface DatabaseConfig {
+    driver?: "sqlite" | "libsql" | "postgres";
+    sqlite?: SqliteDatabaseConfig;
+    libsql?: LibsqlDatabaseConfig;
+    postgres?: PostgresDatabaseConfig;
+}
+export interface DocumentStore {
+    ensure(): Promise<void>;
+    create(data: DocumentRecord): Promise<any>;
+    clone(data: DocumentRecord & {
+        id: string;
+    }): Promise<any>;
+    update(id: string, patch: DocumentRecord): Promise<any>;
+    remove(id: string): Promise<any>;
+    updateOneByQuery(query: DocumentQuery, update: DocumentUpdate, options?: DocumentUpdateOptions): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedId: string | null;
+    }>;
+    updateManyByQuery(query: DocumentQuery, update: DocumentUpdate): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    deleteManyByQuery(query: DocumentQuery): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    bulkWrite(operations: {
+        updateOne: {
+            filter: DocumentQuery;
+            update: DocumentUpdate;
+            upsert?: boolean;
+        };
+    }[]): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedId: string | null;
+    }>;
+    find(query?: DocumentQuery, options?: FindManyOptions): Promise<any[]>;
+    findIds(query?: DocumentQuery, options?: {
+        sort?: SortOption;
+        skip?: number | null;
+        limit?: number | null;
+        sample?: number;
+    }): Promise<string[]>;
+    findOne(query?: DocumentQuery, options?: FindOneOptions): Promise<any | null>;
+    findId(query?: DocumentQuery, options?: {
+        sort?: SortOption;
+        skip?: number | null;
+        sample?: boolean;
+    }): Promise<string | null>;
+    pickOne(query?: DocumentQuery, options?: FindOneOptions): Promise<any>;
+    pickById(id: string): Promise<any>;
+    exists(query?: DocumentQuery): Promise<string | null>;
+    count(query?: DocumentQuery): Promise<number>;
+    insight(query?: DocumentQuery): Promise<any>;
+    hydrate(data: DocumentRecord, originalData?: DocumentRecord): any;
+}
+export interface SqlResultRows<Row = Record<string, unknown>> {
+    rows: Row[];
+}
+export interface AkanSqlStatement {
+    run(...params: unknown[]): Promise<unknown>;
+    get<Row = Record<string, unknown>>(...params: unknown[]): Promise<Row | null>;
+    all<Row = Record<string, unknown>>(...params: unknown[]): Promise<Row[]>;
+}
+export interface AkanSqlClient {
+    execute(sql: string, params?: unknown[] | Record<string, unknown>): Promise<unknown>;
+    prepare(sql: string): AkanSqlStatement;
+    close(): Promise<void>;
+}
+export interface DatabaseAdaptor {
+    getConnection(): AkanSqlClient;
+    getStore(constant: ConstantModel, database: DatabaseModel, schema: DocumentSchema): DocumentStore;
+    transaction<T>(fn: () => PromiseOrObject<T>): Promise<T>;
+}
+interface SqliteEnv extends BaseEnv {
+    workspaceRoot?: string;
+    database?: DatabaseConfig;
+}
+type DocumentRecord = Record<string, unknown>;
+type FieldMap = Record<string, {
+    getProps: () => Record<string, unknown>;
+    [key: string]: unknown;
+}>;
+type SortOption = Record<string, 1 | -1> | null | undefined;
+type ProjectionOption = Partial<Record<string, boolean>> | null | undefined;
+type FindManyOptions = {
+    sort?: SortOption;
+    skip?: number | null;
+    limit?: number | null;
+    sample?: number;
+    select?: ProjectionOption;
+};
+type FindOneOptions = {
+    sort?: SortOption;
+    skip?: number | null;
+    sample?: boolean;
+    select?: ProjectionOption;
+};
+interface DocumentDatabaseOwner {
+    getConnection(): AkanSqlClient;
+    getMeta(key: string): Promise<string | undefined> | string | undefined;
+    setMeta(key: string, value: string): Promise<void>;
+    afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
+}
+declare class BunSqliteClient implements AkanSqlClient {
+    readonly db: Database;
+    constructor(db: Database);
+    execute(sql: string, params?: unknown[] | Record<string, unknown>): Promise<import("bun:sqlite").Changes>;
+    prepare(sql: string): AkanSqlStatement;
+    close(): Promise<void>;
+}
+declare class LibsqlAkanClient implements AkanSqlClient {
+    readonly client: LibsqlClient;
+    constructor(client: LibsqlClient);
+    execute(sql: string, params?: unknown[] | Record<string, unknown>): Promise<import("@libsql/client").ResultSet>;
+    prepare(sql: string): AkanSqlStatement;
+    close(): Promise<void>;
+}
+declare class PostgresAkanClient implements AkanSqlClient {
+    readonly client: Sql;
+    constructor(client: Sql);
+    execute(sql: string, params?: unknown[] | Record<string, unknown>): Promise<import("postgres").RowList<(import("postgres").Row & Iterable<import("postgres").Row>)[]>>;
+    prepare(sql: string): AkanSqlStatement;
+    close(): Promise<void>;
+}
+declare class QueryCompiler {
+    private readonly fields;
+    constructor(fields: FieldMap);
+    compile(query?: DocumentQuery): {
+        where: string;
+        params: unknown[];
+    };
+    orderBy(sort?: Record<string, 1 | -1>): string;
+    fieldExpr(path: string): string;
+    private compileNode;
+    private compileField;
+    private compileArrayHas;
+    private assertPath;
+    private isQueryNode;
+}
+export declare class SqliteDocumentStore {
+    #private;
+    private readonly owner;
+    readonly constant: ConstantModel;
+    readonly database: DatabaseModel;
+    readonly schema: DocumentSchema;
+    readonly table: string;
+    readonly compiler: QueryCompiler;
+    constructor(owner: DocumentDatabaseOwner, constant: ConstantModel, database: DatabaseModel, schema: DocumentSchema);
+    ensure(): Promise<void>;
+    create(data: DocumentRecord): Promise<any>;
+    clone(data: DocumentRecord & {
+        id: string;
+    }): Promise<any>;
+    update(id: string, patch: DocumentRecord): Promise<any>;
+    remove(id: string): Promise<any>;
+    updateOneByQuery(query: DocumentQuery, update: DocumentUpdate, options?: DocumentUpdateOptions): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedId: any;
+    }>;
+    updateManyByQuery(query: DocumentQuery, update: DocumentUpdate): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    deleteManyByQuery(query: DocumentQuery): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    bulkWrite(operations: {
+        updateOne: {
+            filter: DocumentQuery;
+            update: DocumentUpdate;
+            upsert?: boolean;
+        };
+    }[]): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedId: string | null;
+    }>;
+    find(query?: DocumentQuery, options?: FindManyOptions): Promise<any[]>;
+    findIds(query?: DocumentQuery, options?: {
+        sort?: SortOption;
+        skip?: number | null;
+        limit?: number | null;
+        sample?: number;
+    }): Promise<string[]>;
+    findOne(query?: DocumentQuery, options?: FindOneOptions): Promise<any>;
+    findId(query?: DocumentQuery, options?: {
+        sort?: SortOption;
+        skip?: number | null;
+        sample?: boolean;
+    }): Promise<string | null>;
+    pickOne(query?: DocumentQuery, options?: FindOneOptions): Promise<any>;
+    pickById(id: string): Promise<any>;
+    exists(query?: DocumentQuery): Promise<string | null>;
+    count(query?: DocumentQuery): Promise<number>;
+    insight(query?: DocumentQuery): Promise<DocumentRecord>;
+    search(searchText: string | undefined | null, options?: {
+        skip?: number | null;
+        limit?: number | null;
+        sort?: SortOption;
+    }): Promise<{
+        docs: any[];
+        count: number;
+    }>;
+    private safeQuery;
+    private prepareDocument;
+    private extractInsertBase;
+    private applyDocumentUpdate;
+    private toRow;
+    private fromRow;
+    private normalizeProjection;
+    private projectionSql;
+    private projectionAlias;
+    private fromProjectedRow;
+    private parseProjectedValue;
+    private decodeDocumentPayload;
+    private decodeFieldValue;
+    private decodeMapValue;
+    private decodeNestedValue;
+    private normalizeWriteValue;
+    private fillScalarDefaults;
+    hydrate(data: DocumentRecord, originalData?: DocumentRecord): any;
+    private runHooks;
+    private insertStmt;
+    private prepareReadStmt;
+    private assertValidRefName;
+}
+declare const SqliteDatabase_base: import("..").AdaptorCls<{}, {
+    config: import("..").InjectInfo<"env", {
+        filePath: string;
+        journalMode: "WAL" | "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY" | "OFF";
+        busyTimeoutMs: number;
+        synchronous: "OFF" | "NORMAL" | "FULL" | "EXTRA";
+        foreignKeys: boolean;
+        cacheSize?: number;
+        tempStore?: "DEFAULT" | "FILE" | "MEMORY";
+    }, SqliteEnv, never>;
+}>;
+export declare class SqliteDatabase extends SqliteDatabase_base implements DatabaseAdaptor {
+    #private;
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    getConnection(): BunSqliteClient;
+    getStore(constant: ConstantModel, database: DatabaseModel, schema: SchemaOf): SqliteDocumentStore;
+    getMeta(key: string): string | undefined;
+    setMeta(key: string, value: string): Promise<void>;
+    transaction<T>(fn: () => PromiseOrObject<T>): Promise<T>;
+    afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
+    checkpoint(mode?: "PASSIVE" | "FULL" | "RESTART" | "TRUNCATE"): void;
+    vacuum(): void;
+}
+declare const LibsqlDatabase_base: import("..").AdaptorCls<{}, {
+    config: import("..").InjectInfo<"env", {
+        url: string;
+        authToken: string | undefined;
+    }, SqliteEnv, never>;
+}>;
+export declare class LibsqlDatabase extends LibsqlDatabase_base implements DatabaseAdaptor {
+    #private;
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    getConnection(): LibsqlAkanClient;
+    getStore(constant: ConstantModel, database: DatabaseModel, schema: SchemaOf): SqliteDocumentStore;
+    getMeta(key: string): Promise<string | undefined>;
+    setMeta(key: string, value: string): Promise<void>;
+    transaction<T>(fn: () => PromiseOrObject<T>): Promise<T>;
+    afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
+}
+declare const PostgresDatabase_base: import("..").AdaptorCls<{}, {
+    config: import("..").InjectInfo<"env", {
+        url: string | undefined;
+        host: string;
+        port: number;
+        database: string;
+        user: string;
+        password: string;
+    }, SqliteEnv, never>;
+}>;
+export declare class PostgresDatabase extends PostgresDatabase_base implements DatabaseAdaptor {
+    #private;
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    getConnection(): PostgresAkanClient;
+    getStore(constant: ConstantModel, database: DatabaseModel, schema: SchemaOf): SqliteDocumentStore;
+    getMeta(key: string): Promise<string | undefined>;
+    setMeta(key: string, value: string): Promise<void>;
+    transaction<T>(fn: () => PromiseOrObject<T>): Promise<T>;
+    afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
+}
+export {};

package/types/service/predefinedAdaptor/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./cache.adaptor";
+export * from "./compress.adaptor";
+export * from "./database.adaptor";
+export * from "./logging.adaptor";
+export * from "./queue.adaptor";
+export * from "./role.adaptor";
+export * from "./schedule.adaptor";
+export * from "./solidCache.adaptor";
+export * from "./solidPubsub.adaptor";
+export * from "./solidQueue.adaptor";
+export * from "./solidSqlite.d.ts";
+export * from "./storage.adaptor";
+export * from "./websocket.adaptor";

package/types/service/predefinedAdaptor/logging.adaptor.d.ts

@@ -0,0 +1,20 @@
+export interface LoggingAdaptor {
+    trace(name: string, msg: string, context?: string): void;
+    verbose(name: string, msg: string, context?: string): void;
+    debug(name: string, msg: string, context?: string): void;
+    log(name: string, msg: string, context?: string): void;
+    info(name: string, msg: string, context?: string): void;
+    warn(name: string, msg: string, context?: string): void;
+    error(name: string, msg: string, context?: string): void;
+}
+declare const ConsoleLogger_base: import("..").AdaptorCls<{}, {}>;
+export declare class ConsoleLogger extends ConsoleLogger_base implements LoggingAdaptor {
+    trace(name: string, msg: string, context?: string): void;
+    verbose(name: string, msg: string, context?: string): void;
+    debug(name: string, msg: string, context?: string): void;
+    log(name: string, msg: string, context?: string): void;
+    info(name: string, msg: string, context?: string): void;
+    warn(name: string, msg: string, context?: string): void;
+    error(name: string, msg: string, context?: string): void;
+}
+export {};

package/types/service/predefinedAdaptor/queue.adaptor.d.ts

@@ -0,0 +1,22 @@
+import type { BaseEnv } from "akanjs/base";
+import type { AkanJob, AkanJobOptions, AkanWorker } from "../ipcTypes.d.ts";
+type QueueLike = {
+    add(name: string, args: unknown[], options?: AkanJobOptions): Promise<unknown>;
+};
+type WorkerLike = AkanWorker;
+export interface QueueAdaptor {
+    registerProcessWorker(key: string, handler: (job: AkanJob) => Promise<void>): AkanWorker;
+    registerProcessQueue(key: string, args: unknown[], jobOptions?: AkanJobOptions): Promise<AkanJob>;
+}
+declare const BullQueue_base: import("..").AdaptorCls<{}, {
+    redis: import("..").InjectInfo<"plug", import("ioredis").default, never, never>;
+    prefix: import("..").InjectInfo<"env", string, BaseEnv, never>;
+}>;
+export declare class BullQueue extends BullQueue_base implements QueueAdaptor {
+    #private;
+    onInit(): Promise<void>;
+    getQueue(): QueueLike;
+    registerProcessWorker(key: string, handler: (job: AkanJob) => Promise<void>): WorkerLike;
+    registerProcessQueue(key: string, args: unknown[], jobOptions?: AkanJobOptions): Promise<AkanJob>;
+}
+export {};

package/types/service/predefinedAdaptor/role.adaptor.d.ts

@@ -0,0 +1,17 @@
+import { type AdaptorCls } from "../adapt.d.ts";
+import type { CacheAdaptor } from "./cache.adaptor";
+import type { CompressAdaptor } from "./compress.adaptor";
+import type { DatabaseAdaptor } from "./database.adaptor";
+import type { LoggingAdaptor } from "./logging.adaptor";
+import type { QueueAdaptor } from "./queue.adaptor";
+import type { ScheduleAdaptor } from "./schedule.adaptor";
+import type { StorageAdaptor } from "./storage.adaptor";
+import type { WebsocketAdaptor } from "./websocket.adaptor";
+export declare const DatabaseAdaptorRole: AdaptorCls<DatabaseAdaptor>;
+export declare const CacheAdaptorRole: AdaptorCls<CacheAdaptor>;
+export declare const StorageAdaptorRole: AdaptorCls<StorageAdaptor>;
+export declare const QueueAdaptorRole: AdaptorCls<QueueAdaptor>;
+export declare const ScheduleAdaptorRole: AdaptorCls<ScheduleAdaptor>;
+export declare const LoggingAdaptorRole: AdaptorCls<LoggingAdaptor>;
+export declare const WebsocketAdaptorRole: AdaptorCls<WebsocketAdaptor>;
+export declare const CompressAdaptorRole: AdaptorCls<CompressAdaptor>;

package/types/service/predefinedAdaptor/schedule.adaptor.d.ts

@@ -0,0 +1,60 @@
+import { Cron } from "croner";
+export interface ScheduleAdaptor {
+    getCron(key: string): Cron | undefined;
+    registerCron(key: string, cronStr: string, callback: () => Promise<void>, option?: {
+        lock?: boolean;
+    }): Cron;
+    unregisterCron(key: string): void;
+    getInterval(key: string): NodeJS.Timeout | undefined;
+    registerInterval(key: string, scheduleTime: number, callback: () => Promise<void>, option?: {
+        lock?: boolean;
+    }): NodeJS.Timeout;
+    unregisterInterval(key: string): void;
+    getTimeout(key: string): NodeJS.Timeout | undefined;
+    registerTimeout(key: string, timeout: number, callback: () => Promise<void>, option?: {
+        lock?: boolean;
+    }): NodeJS.Timeout;
+    unregisterTimeout(key: string): void;
+    getInit(key: string): (() => Promise<void>) | undefined;
+    registerInit(key: string, callback: () => Promise<void>): void;
+    unregisterInit(key: string): void;
+    _runInit(): Promise<void>;
+    getDestroy(key: string): (() => Promise<void>) | undefined;
+    registerDestroy(key: string, callback: () => Promise<void>): void;
+    unregisterDestroy(key: string): void;
+    _runDestroy(): Promise<void>;
+}
+declare const Scheduler_base: import("..").AdaptorCls<{}, {
+    cache: import("..").InjectInfo<"plug", import("./cache.adaptor").CacheAdaptor, never, never>;
+}>;
+export declare class Scheduler extends Scheduler_base implements ScheduleAdaptor {
+    readonly lockMap: Map<string, boolean>;
+    readonly cronMap: Map<string, Cron<undefined>>;
+    readonly intervalMap: Map<string, NodeJS.Timeout>;
+    readonly timeoutMap: Map<string, NodeJS.Timeout>;
+    readonly initMap: Map<string, () => Promise<void>>;
+    readonly destroyMap: Map<string, () => Promise<void>>;
+    getCron(key: string): Cron<undefined> | undefined;
+    registerCron(key: string, cronStr: string, callback: () => Promise<void>, { lock }?: {
+        lock?: boolean;
+    }): Cron<undefined>;
+    unregisterCron(key: string): void;
+    getInterval(key: string): NodeJS.Timeout | undefined;
+    registerInterval(key: string, scheduleTime: number, callback: () => Promise<void>, { lock }?: {
+        lock?: boolean;
+    }): NodeJS.Timeout;
+    unregisterInterval(key: string): void;
+    getTimeout(key: string): NodeJS.Timeout | undefined;
+    registerTimeout(key: string, scheduleTime: number, callback: () => Promise<void>): NodeJS.Timeout;
+    unregisterTimeout(key: string): void;
+    getInit(key: string): (() => Promise<void>) | undefined;
+    registerInit(key: string, callback: () => Promise<void>): void;
+    unregisterInit(key: string): void;
+    _runInit(): Promise<void>;
+    getDestroy(key: string): (() => Promise<void>) | undefined;
+    registerDestroy(key: string, callback: () => Promise<void>): void;
+    unregisterDestroy(key: string): void;
+    _runDestroy(): Promise<void>;
+    onDestroy(): Promise<void>;
+}
+export {};

package/types/service/predefinedAdaptor/solidCache.adaptor.d.ts

@@ -0,0 +1,25 @@
+import type { Dayjs } from "akanjs/base";
+import type { CacheAdaptor } from "./cache.adaptor";
+import { type SolidConfig, type SolidEnv } from "./solidSqlite.d.ts";
+declare const SolidCache_base: import("..").AdaptorCls<{}, {
+    config: import("..").InjectInfo<"env", Required<SolidConfig>, SolidEnv, never>;
+}>;
+export declare class SolidCache extends SolidCache_base implements CacheAdaptor {
+    #private;
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    set(topic: string, key: string, value: string | number | Buffer, option?: {
+        expireAt?: Dayjs;
+    }): Promise<void>;
+    get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined>;
+    delete(topic: string, key: string): Promise<void>;
+    hset(topic: string, key: string, subKey: string, value: string | number | Buffer, option?: {
+        expireAt?: Dayjs;
+    }): Promise<void>;
+    hget<T extends string | number | Buffer>(topic: string, key: string, subKey: string): Promise<T | undefined>;
+    hdelete(topic: string, key: string, subKey: string): Promise<void>;
+    hkeys(topic: string, key: string): Promise<string[]>;
+    hentries<T extends string | number | Buffer>(topic: string, key: string): Promise<[string, T][]>;
+    hclear(topic: string, key: string): Promise<void>;
+}
+export {};

package/types/service/predefinedAdaptor/solidPubsub.adaptor.d.ts

@@ -0,0 +1,20 @@
+import type { BaseEnv, Cls } from "akanjs/base";
+import type { WebsocketAdaptor, WsRedisEventHandler } from "./websocket.adaptor";
+declare const SolidPubSub_base: import("..").AdaptorCls<{}, {
+    serverId: import("..").InjectInfo<"env", string, BaseEnv, never>;
+}>;
+export declare class SolidPubSub extends SolidPubSub_base implements WebsocketAdaptor {
+    #private;
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    publish(roomId: string, data: unknown): void;
+    setEventHandler(handler: WsRedisEventHandler): void;
+    clearEventHandler(): void;
+    registerEndpoint(key: string, returnRef: Cls, arrDepth: number): void;
+    joinRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void>;
+    leaveRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void>;
+    leaveAllRooms(ws: Bun.ServerWebSocket<unknown>): Promise<void>;
+    registerSocket(ws: Bun.ServerWebSocket<unknown>): Promise<void>;
+    unregisterSocket(ws: Bun.ServerWebSocket<unknown>): Promise<void>;
+}
+export {};

package/types/service/predefinedAdaptor/solidQueue.adaptor.d.ts

@@ -0,0 +1,19 @@
+import { type AkanJob, type AkanJobOptions, type AkanWorker } from "../ipcTypes.d.ts";
+import type { QueueAdaptor } from "./queue.adaptor";
+import { type SolidConfig, type SolidEnv } from "./solidSqlite.d.ts";
+declare const SolidQueue_base: import("..").AdaptorCls<{}, {
+    config: import("..").InjectInfo<"env", Required<SolidConfig>, SolidEnv, never>;
+    queueName: import("..").InjectInfo<"env", string, SolidEnv, never>;
+    workerId: import("..").InjectInfo<"env", string, SolidEnv, never>;
+}>;
+export declare class SolidQueue extends SolidQueue_base implements QueueAdaptor {
+    #private;
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    registerProcessWorker(key: string, handler: (job: AkanJob) => Promise<void>): AkanWorker;
+    registerProcessQueue(key: string, args: unknown[], jobOptions?: AkanJobOptions): Promise<AkanJob>;
+    wake(name?: string): void;
+    claimJob(name: string): AkanJob | null;
+    runJob(job: AkanJob, handler: (job: AkanJob) => Promise<void>): Promise<void>;
+}
+export {};

package/types/service/predefinedAdaptor/solidSqlite.d.ts

@@ -0,0 +1,24 @@
+import { Database } from "bun:sqlite";
+import type { BaseEnv, Dayjs } from "akanjs/base";
+export interface SolidConfig {
+    filePath?: string;
+    journalMode?: "WAL" | "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY" | "OFF";
+    busyTimeoutMs?: number;
+    synchronous?: "OFF" | "NORMAL" | "FULL" | "EXTRA";
+    cleanupIntervalMs?: number;
+    queuePollIntervalMs?: number;
+    queueLeaseMs?: number;
+}
+export interface SolidEnv extends BaseEnv {
+    workspaceRoot?: string;
+    solid?: SolidConfig;
+}
+export type SolidValueType = "string" | "number" | "buffer" | "json";
+export declare const getSolidConfig: (env: SolidEnv) => Required<SolidConfig>;
+export declare const openSolidDatabase: (config: Required<SolidConfig>) => Promise<Database>;
+export declare const encodeSolidValue: (value: unknown) => {
+    type: SolidValueType;
+    value: string | Buffer;
+};
+export declare const decodeSolidValue: <T>(type: SolidValueType, value: string | Buffer | null) => T | undefined;
+export declare const toEpochMs: (value?: Dayjs | number | null) => number | null;

package/types/service/predefinedAdaptor/sqlitePath.d.ts

@@ -0,0 +1,9 @@
+interface ResolveDefaultSqliteFileOptions {
+    appName: string;
+    fileName: string;
+    isProduction: boolean;
+    operationMode?: string;
+    workspaceRoot?: string;
+}
+export declare const resolveDefaultSqliteFile: ({ appName, fileName, isProduction, operationMode, workspaceRoot, }: ResolveDefaultSqliteFileOptions) => string;
+export {};

package/types/service/predefinedAdaptor/storage.adaptor.d.ts

@@ -0,0 +1,80 @@
+import type { BaseEnv } from "akanjs/base";
+export interface DownloadRequest {
+    path: string;
+    localPath: string;
+    renamePath?: string;
+}
+export interface LocalFilePath {
+    localPath: string;
+}
+export interface UploadRequest {
+    path: string;
+    localPath: string;
+    meta?: {
+        [key: string]: string;
+    };
+    rename?: string;
+    host?: string;
+    access?: "public" | "private";
+}
+export interface CopyRequest {
+    bucket: string;
+    copyPath: string;
+    pastePath: string;
+    filename: string;
+    host?: string;
+}
+export interface UploadFromStreamRequest {
+    path: string;
+    body: ReadableStream;
+    mimetype: string;
+    root?: string;
+    access?: "public" | "private";
+    updateProgress: (progress: {
+        loaded?: number;
+        total?: number;
+        part?: number;
+    }) => void;
+    uploadSuccess: (url: string) => void;
+}
+export interface UploadProgress {
+    loaded?: number;
+    total?: number;
+    part?: number;
+}
+export interface StorageAdaptor {
+    readData(path: string): Promise<ReadableStream>;
+    readDataAsJson<T>(path: string): Promise<T>;
+    getDataList(prefix?: string): Promise<string[]>;
+    uploadDataFromLocal(request: UploadRequest): Promise<string>;
+    uploadDataFromStream(request: UploadFromStreamRequest): void;
+    saveData(request: DownloadRequest): Promise<LocalFilePath>;
+    copyData(request: CopyRequest): Promise<string>;
+    deleteData(url: string): Promise<boolean>;
+    deleteDataByPath(path: string): Promise<boolean>;
+}
+export interface BlobStorageOptions extends BaseEnv {
+    blobStorage?: {
+        baseDir?: string;
+        privateBaseDir?: string;
+        urlPrefix?: string;
+    };
+}
+declare const BlobStorage_base: import("..").AdaptorCls<{}, {
+    root: import("..").InjectInfo<"env", string, BlobStorageOptions, never>;
+    privateRoot: import("..").InjectInfo<"env", string, BlobStorageOptions, never>;
+    urlPrefix: import("..").InjectInfo<"env", string | undefined, BlobStorageOptions, never>;
+}>;
+export declare class BlobStorage extends BlobStorage_base implements StorageAdaptor {
+    #private;
+    readData(path: string): Promise<ReadableStream>;
+    readDataAsJson<T>(path: string): Promise<T>;
+    getDataList(prefix?: string): Promise<string[]>;
+    uploadDataFromLocal({ path, localPath, meta, access }: UploadRequest): Promise<string>;
+    uploadDataFromStream({ path, body, mimetype, updateProgress, uploadSuccess, access, }: UploadFromStreamRequest): Promise<void>;
+    saveData({ path, localPath, renamePath }: DownloadRequest): Promise<LocalFilePath>;
+    copyData({ copyPath, pastePath, host }: CopyRequest): Promise<string>;
+    deleteDataByPath(path: string): Promise<boolean>;
+    deleteData(url: string): Promise<boolean>;
+}
+export {};