akanjs 2.2.4-rc.5 → 2.2.4

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,80 +0,0 @@
-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 {};