Transitioning from D1 to DOs

class WorkspacesEntrypoint extends WorkerEntrypoint<Env> {
    async fetch(request: Request): Promise<Response> {
        return app.fetch(request, this.env, this.ctx);
    }
}

import { drizzle } from 'drizzle-orm/durable-sqlite';
import * as schema from '@/features/workspace/database/workspace.schema';
import { type Workspace, type CreateWorkspace, workspaces } from '@/features/workspace/database/workspace.schema';
import { eq, and, isNull } from 'drizzle-orm';
import { WorkspaceRepositoryInterface } from './workspace-repository.interface';

export class WorkspaceRepository implements WorkspaceRepositoryInterface {
    private readonly db;

    constructor(private readonly storage: DurableObjectStorage) {
        this.db = drizzle(this.storage, { schema });
    }

    async save(workspace: CreateWorkspace): Promise<void> {
        await this.db.insert(workspaces).values(workspace).returning();
    }

    async findOneBy(field: keyof Workspace, value: string): Promise<Workspace | null> {
        const result = await this.db.query.workspaces.findFirst({
            where: eq(workspaces[field], value),
        });

        return result ?? null;
    }
}

import { type Context } from 'hono';
import { createFactory } from 'hono/factory';
import { WorkspaceRepository } from '@/features/workspace/repository/workspace.repository';
import { type WorkspaceRepositoryInterface } from '@/features/workspace/repository/workspace-repository.interface';

const factory = createFactory();

export const workspaceRepository = (c: Context) => new WorkspaceRepository(c.env.DB);

export const bootstrap = factory.createMiddleware(async (c: Context, next) => {
    c.set('workspaceRepository', workspaceRepository(c));
    await next();
});

export type Repositories = {
    workspaceRepository: WorkspaceRepositoryInterface;
};