@opencode-ai/core 0.0.0-dev-17471

package/dist/types/config/plugin/source.d.ts

@@ -0,0 +1,25 @@
+export * as ConfigPluginSource from "./source.js";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Context, Effect, Layer, Scope, Stream } from "effect";
+import { Config } from "../../config.js";
+import { Watcher } from "../../filesystem/watcher.js";
+import { Location } from "../../location.js";
+export type Operation = {
+    readonly type: "add";
+    readonly target: string;
+    readonly options: Record<string, unknown>;
+    readonly mtime?: number;
+} | {
+    readonly type: "remove";
+    readonly target: string;
+};
+export interface Interface {
+    readonly operations: () => Effect.Effect<readonly Operation[], never, Scope.Scope>;
+    readonly changes: () => Stream.Stream<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ConfigPluginSource", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, FSUtil.Service | Location.Service | Watcher.Service | Config.Service>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;
+export declare const empty: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/config/plugin/websearch.d.ts

@@ -0,0 +1,3 @@
+export * as ConfigWebSearchPlugin from "./websearch.js";
+import { Config } from "../../config.js";
+export declare const Plugin: import("@opencode-ai/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service>;

package/dist/types/config/variable.d.ts

@@ -0,0 +1,60 @@
+export * as ConfigVariable from "./variable.js";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+type ParseSource = {
+    type: "path";
+    path: string;
+} | {
+    type: "virtual";
+    source: string;
+    dir: string;
+};
+type SubstituteInput = ParseSource & {
+    text: string;
+    missing?: "error" | "empty";
+    env?: Record<string, string>;
+};
+/** Apply {env:VAR} and {file:path} substitutions to config text. */
+export declare const substitute: (input: SubstituteInput) => Effect.Effect<string, {
+    readonly name: "ConfigInvalidError";
+    readonly data: {
+        readonly path: string;
+        readonly message?: string | undefined;
+        readonly issues?: readonly {
+            readonly [x: string]: unknown;
+            readonly message: string;
+            readonly path: readonly string[];
+        }[] | undefined;
+    };
+    schema(): import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").Literal<"ConfigInvalidError">;
+        readonly data: import("effect/Schema").Struct<{
+            path: import("effect/Schema").String;
+            issues: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+                readonly message: import("effect/Schema").String;
+                readonly path: import("effect/Schema").$Array<import("effect/Schema").String>;
+            }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>]>>>;
+            message: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>;
+    }>;
+    toObject(): {
+        name: "ConfigInvalidError";
+        data: {
+            readonly path: string;
+            readonly message?: string | undefined;
+            readonly issues?: readonly {
+                readonly [x: string]: unknown;
+                readonly message: string;
+                readonly path: readonly string[];
+            }[] | undefined;
+        };
+    };
+    message: string;
+    stack?: string;
+    cause?: unknown;
+    readonly "~effect/Runtime/errorExitCode"?: number;
+    readonly "~effect/Runtime/errorReported"?: boolean;
+    readonly "~effect/ErrorReporter/ignore"?: boolean;
+    readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+    readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+}, FSUtil.Service>;

package/dist/types/config.d.ts

@@ -0,0 +1,53 @@
+export * as Config from "./config.js";
+import { Context, Effect, Layer, Schema, Stream } from "effect";
+import { type Draft } from "immer";
+import { Info, type Entry } from "@opencode-ai/schema/config";
+import { Credential } from "./credential.js";
+import { Bus } from "./bus.js";
+import { Watcher } from "./filesystem/watcher.js";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { Location } from "./location.js";
+import { WellKnown } from "./wellknown.js";
+export declare function latest<K extends keyof Info>(entries: readonly Entry[], key: K): Info[K] | undefined;
+export interface Interface {
+    /** Returns location config documents and discovery sources from lowest to highest priority. */
+    readonly entries: () => Effect.Effect<Entry[]>;
+    /** Updates the first file-backed configuration document. */
+    readonly update: (update: (draft: Draft<Info>) => void) => Effect.Effect<Info, UpdateError>;
+    /**
+     * Streams raw filesystem updates under config roots. Config owns root
+     * topology and watch reconciliation; domain owners filter this feed for the
+     * source files they parse and rebuild their own state.
+     */
+    readonly changes: () => Stream.Stream<Watcher.Update>;
+}
+declare const UpdateError_base: Schema.Class<UpdateError, Schema.TaggedStruct<"Config.UpdateError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class UpdateError extends UpdateError_base {
+}
+export declare const Options: Schema.Struct<{
+    readonly project: Schema.optional<Schema.Boolean>;
+    readonly file: Schema.optional<Schema.String>;
+    readonly content: Schema.optional<Schema.String>;
+}>;
+export type Options = typeof Options.Type;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Config", Interface>;
+export declare class Service extends Service_base {
+}
+export interface TestInterface extends Interface {
+    /** Replaces the entries returned by subsequent entries() calls. */
+    readonly setEntries: (entries: Entry[]) => Effect.Effect<void>;
+    /** Emits one filesystem update to every changes() subscriber. */
+    readonly emitChange: (update: Watcher.Update) => Effect.Effect<void>;
+}
+declare const Test_base: Context.ServiceClass<Test, "@opencode/Config/Test", TestInterface>;
+export declare class Test extends Test_base {
+}
+/** In-memory config for tests: static entries with replaceable state and a test-driven change feed. */
+export declare const testLayer: (initial?: Entry[]) => Layer.Layer<Service | Test, never, never>;
+export declare const layer: (options?: Options) => Layer.Layer<Service, never, Global.Service | FSUtil.Service | Bus.Service | Location.Service | Credential.Service | Watcher.Service | WellKnown.Service>;
+export declare function configured(options?: Options): import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/credential/sql.d.ts

@@ -0,0 +1,169 @@
+export declare const CredentialTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "credential";
+    schema: undefined;
+    columns: {
+        time_created: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "credential";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        time_updated: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "credential";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "credential";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Credential.ID">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        integration_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "credential";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Integration.ID">;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        label: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "credential";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        value: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "credential";
+            dataType: "object json";
+            data: {
+                readonly type: "oauth";
+                readonly methodID: string & import("effect/Brand").Brand<"Integration.MethodID">;
+                readonly refresh: string;
+                readonly access: string;
+                readonly expires: number;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "key";
+                readonly key: string;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly configuration?: {
+                    readonly [x: string]: string | number | boolean | readonly string[];
+                } | undefined;
+            };
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        connector_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "credential";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        method_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "credential";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        active: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "credential";
+            dataType: "boolean";
+            data: boolean;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/types/credential.d.ts

@@ -0,0 +1,82 @@
+export * as Credential from "./credential.js";
+import { Context, Effect, Schema } from "effect";
+import { Credential } from "@opencode-ai/schema/credential";
+import { Integration } from "@opencode-ai/schema/integration";
+export declare const ID: Schema.brand<Schema.String, "Credential.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+};
+export type ID = Credential.ID;
+export declare const OAuth: Schema.Struct<{
+    readonly type: Schema.Literal<"oauth">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly refresh: Schema.String;
+    readonly access: Schema.String;
+    readonly expires: Schema.Int;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>;
+export type OAuth = Credential.OAuth;
+export declare const Key: Schema.Struct<{
+    readonly type: Schema.Literal<"key">;
+    readonly key: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+}>;
+export type Key = Credential.Key;
+export declare const Value: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"oauth">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly refresh: Schema.String;
+    readonly access: Schema.String;
+    readonly expires: Schema.Int;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"key">;
+    readonly key: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+}>]>;
+export type Value = Credential.Value;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+    readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+    readonly label: Schema.String;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"oauth">;
+        readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+        readonly refresh: Schema.String;
+        readonly access: Schema.String;
+        readonly expires: Schema.Int;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"key">;
+        readonly key: Schema.String;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+    }>]>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+export interface Interface {
+    /** Returns every stored credential. */
+    readonly all: () => Effect.Effect<Info[]>;
+    /** Returns stored credentials belonging to one integration. */
+    readonly list: (integrationID: Integration.ID) => Effect.Effect<Info[]>;
+    /** Returns one stored credential by ID. */
+    readonly get: (id: ID) => Effect.Effect<Info | undefined>;
+    /** Replaces any credential for an integration and returns the new record. */
+    readonly create: (input: {
+        readonly integrationID: Integration.ID;
+        readonly value: Value;
+        readonly label?: string;
+    }) => Effect.Effect<Info>;
+    /** Updates the label or secret value of a stored credential. */
+    readonly update: (id: ID, updates: Partial<Pick<Info, "label" | "value">>) => Effect.Effect<void>;
+    /** Removes a stored credential. */
+    readonly remove: (id: ID) => Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Credential", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

package/dist/types/database/database.d.ts

@@ -0,0 +1,25 @@
+export * as Database from "./database.js";
+import { EffectDrizzleSqlite } from "./drizzle.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import type { SqlClient } from "effect/unstable/sql";
+import { Global } from "@opencode-ai/util/global";
+declare const makeDatabase: Effect.Effect<EffectDrizzleSqlite.EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: SqlClient.SqlClient;
+}, never, SqlClient.SqlClient>;
+type DatabaseShape = Effect.Success<typeof makeDatabase>;
+export interface Interface {
+    db: DatabaseShape;
+}
+export declare const Options: Schema.Struct<{
+    readonly path: Schema.optional<Schema.String>;
+}>;
+export type Options = typeof Options.Type;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/storage/Database", Interface>;
+export declare class Service extends Service_base {
+}
+export declare function layer(options?: Options): Layer.Layer<Service, never, Global.Service>;
+export declare const layerFromClient: Layer.Layer<Service, never, SqlClient.SqlClient | Global.Service>;
+export declare function configured(options?: Options): import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+/** `configured`, but over an injected SqlClient layer instead of a filesystem path. */
+export declare function configuredClient(client: Layer.Layer<SqlClient.SqlClient>): import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

package/dist/types/database/drizzle/effect-sqlite/driver.d.ts

@@ -0,0 +1,43 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { EffectCache } from "drizzle-orm/cache/core/cache-effect";
+import { EffectLogger } from "drizzle-orm/effect-core";
+import { entityKind } from "drizzle-orm/entity";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+import { SQLiteEffectDatabase } from "../sqlite-core/effect/db.js";
+import type { DrizzleConfig } from "drizzle-orm/utils";
+import { type EffectSQLiteQueryEffectHKT, type EffectSQLiteRunResult } from "./session.js";
+export declare class EffectSQLiteDatabase<TRelations extends AnyRelations = EmptyRelations> extends SQLiteEffectDatabase<EffectSQLiteQueryEffectHKT, EffectSQLiteRunResult, TRelations> {
+    static readonly [entityKind]: string;
+}
+export type EffectDrizzleSQLiteConfig<TRelations extends AnyRelations = EmptyRelations> = Omit<DrizzleConfig<Record<string, never>, TRelations>, "cache" | "logger" | "schema">;
+export declare const DefaultServices: Layer.Layer<EffectCache | EffectLogger, never, never>;
+/**
+ * Creates an EffectSQLiteDatabase instance.
+ *
+ * Requires a generic Effect `SqlClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Drizzle only depends on the generic `SqlClient`; install and provide a compatible SQLite provider such as
+ * `@effect/sql-sqlite-node`, `@effect/sql-sqlite-bun`, or another package that exposes `SqlClient`.
+ *
+ * @example
+ * ```ts
+ * import { SqliteClient } from '@effect/sql-sqlite-node';
+ * import * as SQLiteDrizzle from 'drizzle-orm/effect-sqlite';
+ * import * as Effect from 'effect/Effect';
+ *
+ * const db = yield* SQLiteDrizzle.make({ relations }).pipe(
+ *   Effect.provide(SQLiteDrizzle.DefaultServices),
+ *   Effect.provide(SqliteClient.layer({ filename: 'sqlite.db' })),
+ * );
+ * ```
+ */
+export declare const make: <TRelations extends AnyRelations = EmptyRelations>(config?: EffectDrizzleSQLiteConfig<TRelations> | undefined) => Effect.Effect<EffectSQLiteDatabase<TRelations> & {
+    $client: SqlClient;
+}, never, SqlClient | EffectCache | EffectLogger>;
+/**
+ * Convenience function that creates an EffectSQLiteDatabase with `DefaultServices` already provided.
+ */
+export declare const makeWithDefaults: <TRelations extends AnyRelations = EmptyRelations>(config?: EffectDrizzleSQLiteConfig<TRelations>) => Effect.Effect<EffectSQLiteDatabase<TRelations> & {
+    $client: SqlClient;
+}, never, SqlClient>;

package/dist/types/database/drizzle/effect-sqlite/index.d.ts

@@ -0,0 +1,3 @@
+export { EffectLogger } from "drizzle-orm/effect-core";
+export * from "./driver.js";
+export * from "./session.js";

package/dist/types/database/drizzle/effect-sqlite/migrator.d.ts

@@ -0,0 +1,4 @@
+import type { MigrationConfig } from "drizzle-orm/migrator";
+import type { AnyRelations } from "drizzle-orm/relations";
+import type { EffectSQLiteDatabase } from "./driver.js";
+export declare function migrate<TRelations extends AnyRelations>(db: EffectSQLiteDatabase<TRelations>, config: MigrationConfig): import("effect/Effect").Effect<undefined, import("drizzle-orm/effect-core").EffectDrizzleError | import("effect/unstable/sql/SqlError").SqlError | import("drizzle-orm/effect-core").EffectDrizzleQueryError | import("drizzle-orm/effect-core").MigratorInitError, never>;

package/dist/types/database/drizzle/effect-sqlite/session.d.ts

@@ -0,0 +1,57 @@
+import * as Effect from "effect/Effect";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { EffectCacheShape } from "drizzle-orm/cache/core/cache-effect";
+import type { WithCacheConfig } from "drizzle-orm/cache/core/types";
+import type { EffectDrizzleQueryError } from "drizzle-orm/effect-core/errors";
+import type { EffectLoggerShape } from "drizzle-orm/effect-core/logger";
+import type { QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import type { AnyRelations } from "drizzle-orm/relations";
+import type { RelationalQueryMapperConfig } from "drizzle-orm/relations";
+import type { Query } from "drizzle-orm/sql/sql";
+import type { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core/dialect";
+import { SQLiteEffectPreparedQuery, SQLiteEffectSession, SQLiteEffectTransaction } from "../sqlite-core/effect/session.js";
+import type { SelectedFieldsOrdered } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { PreparedQueryConfig, SQLiteExecuteMethod, SQLiteTransactionConfig } from "drizzle-orm/sqlite-core/session";
+export interface EffectSQLiteQueryEffectHKT extends QueryEffectHKTBase {
+    readonly error: EffectDrizzleQueryError;
+    readonly context: never;
+}
+/**
+ * A SqlClient whose runtime rejects SQL transaction statements (BEGIN/COMMIT/SAVEPOINT) and
+ * manages transactions natively instead — Cloudflare Durable Object SQLite. Producers set
+ * `transactionStatements: false` (see `database/sqlite.workerd.ts`) and the session delegates
+ * to the client's `withTransaction` rather than issuing transaction statements.
+ */
+export interface NativeTransactionSqlClient extends SqlClient {
+    readonly transactionStatements: false;
+}
+export declare function managesTransactionsNatively(client: SqlClient): client is NativeTransactionSqlClient;
+export type EffectSQLiteRunResult = readonly never[];
+export interface EffectSQLiteSessionOptions {
+    logger: EffectLoggerShape;
+    cache: EffectCacheShape;
+    useJitMappers?: boolean;
+}
+export declare class EffectSQLiteSession<TRelations extends AnyRelations> extends SQLiteEffectSession<EffectSQLiteQueryEffectHKT, EffectSQLiteRunResult, TRelations> {
+    private client;
+    protected relations: TRelations;
+    private options;
+    static readonly [entityKind]: string;
+    constructor(client: SqlClient, dialect: SQLiteAsyncDialect, relations: TRelations, options: EffectSQLiteSessionOptions);
+    prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown, queryMetadata?: {
+        type: "select" | "update" | "delete" | "insert";
+        tables: string[];
+    }, cacheConfig?: WithCacheConfig): SQLiteEffectPreparedQuery<T, EffectSQLiteQueryEffectHKT>;
+    prepareRelationalQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper: (rows: Record<string, unknown>[], mapColumnValue?: (value: unknown) => unknown) => unknown, config: RelationalQueryMapperConfig): SQLiteEffectPreparedQuery<T, EffectSQLiteQueryEffectHKT, true>;
+    private execute;
+    private isInTransaction;
+    private executeTransactionStatement;
+    private withTransaction;
+    transaction<A, E, R>(transaction: (tx: EffectSQLiteTransaction<TRelations>) => Effect.Effect<A, E, R>, config?: SQLiteTransactionConfig): Effect.Effect<A, E | SqlError, R>;
+}
+export declare class EffectSQLiteTransaction<TRelations extends AnyRelations> extends SQLiteEffectTransaction<EffectSQLiteQueryEffectHKT, EffectSQLiteRunResult, TRelations> {
+    static readonly [entityKind]: string;
+    transaction: <A, E, R>(transaction: (tx: SQLiteEffectTransaction<EffectSQLiteQueryEffectHKT, EffectSQLiteRunResult, TRelations>) => Effect.Effect<A, E, R>) => Effect.Effect<A, SqlError | E, R>;
+}

package/dist/types/database/drizzle/index.d.ts

@@ -0,0 +1,5 @@
+export { EffectLogger } from "drizzle-orm/effect-core";
+export * from "./effect-sqlite/driver.js";
+export * from "./effect-sqlite/session.js";
+export { migrate } from "./effect-sqlite/migrator.js";
+export * as EffectDrizzleSqlite from "./index.js";

package/dist/types/database/drizzle/internal/drizzle-utils.d.ts

@@ -0,0 +1,20 @@
+import { Column } from "drizzle-orm/column";
+import type { JoinNullability } from "drizzle-orm/query-builders/select.types";
+import { SQL } from "drizzle-orm/sql/sql";
+import type { SelectedFieldsOrdered } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { SQLiteUpdateSetSource } from "drizzle-orm/sqlite-core/query-builders/update";
+import type { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+import type { UpdateSet } from "drizzle-orm/utils";
+export declare function getTableColumnsRuntime(table: SQLiteTable): Record<string, Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnType>, object>>;
+export declare function getViewSelectedFieldsRuntime(view: SQLiteViewBase): {
+    selectedFields: Record<string, unknown>;
+    name: string;
+};
+export declare function jitCompatCheck(isEnabled: boolean | undefined): boolean;
+export declare function orderSelectedFields<TColumn extends Column>(fields: Record<string, unknown>, pathPrefix?: string[]): SelectedFieldsOrdered;
+export declare function mapUpdateSet<TTable extends SQLiteTable>(table: TTable, values: SQLiteUpdateSetSource<TTable>): UpdateSet;
+export declare function mapResultRow(columns: SelectedFieldsOrdered, row: unknown[], joinsNotNullableMap: Record<string, boolean> | undefined): Record<string, unknown>;
+export declare function getTableLikeName(table: SQLiteTable | Subquery | SQLiteViewBase | SQL): string | undefined;
+export type { JoinNullability };

package/dist/types/database/drizzle/sqlite-core/effect/count.d.ts

@@ -0,0 +1,20 @@
+import type * as Effect from "effect/Effect";
+import { type QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import { SQL, type SQLWrapper } from "drizzle-orm/sql/sql";
+import type { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import type { SQLiteView } from "drizzle-orm/sqlite-core/view";
+import type { SQLiteEffectSession } from "./session.js";
+export interface SQLiteEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends SQL<number>, SQLWrapper<number>, Effect.Effect<number, TEffectHKT["error"], TEffectHKT["context"]> {
+}
+export declare class SQLiteEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends SQL<number> {
+    static readonly [entityKind]: string;
+    private sql;
+    private session;
+    constructor(params: {
+        source: SQLiteTable | SQLiteView | SQL | SQLWrapper;
+        filters?: SQL<unknown>;
+        session: SQLiteEffectSession<TEffectHKT, any, any>;
+    });
+    execute(placeholderValues?: Record<string, unknown>): import("drizzle-orm/effect-core").QueryEffectKind<TEffectHKT, number>;
+}