Cloudflare

$ npx prorm packages --dialects d1 --stores cloudflare-kv,cloudflare-vectorize,r2
1 packages for what you picked:
  npm install @aws-sdk/client-s3

Re-run with --run to execute it here.

$ npm install ts-prorm-orm @aws-sdk/client-s3

$ pnpm add ts-prorm-orm @aws-sdk/client-s3

$ yarn add ts-prorm-orm @aws-sdk/client-s3

$ bun add ts-prorm-orm @aws-sdk/client-s3

notes-api/
  migrations/
    20260926120000-create-notes.js
  scripts/
    migrate-d1.ts       # runs the migrations over the HTTP API
  src/
    worker.ts
  .env                  # CF_ACCOUNT_ID, CF_D1_DATABASE_ID, CF_API_TOKEN (git-ignored)
  wrangler.toml

$ npx wrangler d1 create notes

name = "notes-api"
main = "src/worker.ts"
compatibility_date = "2026-09-01"
compatibility_flags = ["nodejs_compat"]

[[d1_databases]]
binding = "DB"                   # env.DB in the Worker
database_name = "notes"
database_id = "<the id wrangler printed>"

CF_ACCOUNT_ID=0123456789abcdef0123456789abcdef
CF_D1_DATABASE_ID=6f1c2e1a-0000-4000-8000-000000000000
CF_API_TOKEN=...            # a token with D1:Edit

import { Prorm, createMigrator } from 'ts-prorm-orm';

const prorm = new Prorm({
  dialect: 'd1',
  dialectOptions: {
    accountId: process.env.CF_ACCOUNT_ID,
    databaseId: process.env.CF_D1_DATABASE_ID,
    token: process.env.CF_API_TOKEN,
  },
});
await prorm.connect(); // checks all three are set; opens nothing

const migrator = createMigrator({ prorm, path: './migrations' });
await migrator.syncMigrationsTable();

const pending = await migrator.pending();
console.log(`Running ${pending.length} pending migration(s)...`);
const { executed, migrations } = await migrator.up();
console.log(`Executed ${executed} migration(s)`, migrations);

await prorm.close();

$ node --env-file=.env scripts/migrate-d1.ts     # Node 22.18+ runs .ts directly
Running 1 pending migration(s)...
Executed 1 migration(s) [ '20260926120000-create-notes' ]

import { Prorm, DataTypes } from 'ts-prorm-orm';

interface Env {
  DB: unknown; // a D1Database, typed by @cloudflare/workers-types if you use it
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const db = new Prorm({ dialect: 'd1', dialectOptions: { binding: env.DB } });
    await db.connect();

    const Note = db.define(
      'Note',
      {
        title: { type: DataTypes.STRING, allowNull: false },
        done: { type: DataTypes.BOOLEAN, defaultValue: false },
      },
      { tableName: 'notes' },
    );

    if (request.method === 'POST') {
      const { title } = (await request.json()) as { title: string };
      const note = await Note.create({ title });
      return Response.json(note.toJSON(), { status: 201 });
    }

    const open = await Note.findAll({
      where: { done: false },
      order: [['id', 'DESC']],
      limit: 50,
    });
    return Response.json(open.map((n) => n.toJSON()));
  },
};

$ npx wrangler dev          # Miniflare's local D1 behind the same binding
$ npx wrangler deploy

import { Prorm, fromHyperdrive } from 'ts-prorm-orm';

export default {
  async fetch(request: Request, env: Env) {
    const prorm = new Prorm(fromHyperdrive(env.HYPERDRIVE));
    await prorm.connect();
    // …everything else is ordinary Postgres.
  },
};

compatibility_flags = ["nodejs_compat"]   # the pg and mysql2 drivers need Node's APIs

[[hyperdrive]]
binding = "HYPERDRIVE"
id = "<the id from: npx wrangler hyperdrive create …>"

import { Prorm, fromHyperdrive } from 'ts-prorm-orm';

export default {
  async fetch(request: Request, env: Env) {
    const prorm = new Prorm(fromHyperdrive(env.HYPERDRIVE)); // postgres is the default
    await prorm.connect();
    try {
      const rows = await prorm.query('SELECT now() AS at'); // a SELECT returns its rows
      return Response.json(rows);
    } finally {
      await prorm.close();
    }
  },
};

import { Prorm, fromHyperdrive } from 'ts-prorm-orm';

export default {
  async fetch(request: Request, env: Env) {
    const prorm = new Prorm(fromHyperdrive(env.HYPERDRIVE, { dialect: 'mysql' }));
    await prorm.connect();
    try {
      const rows = await prorm.query('SELECT NOW() AS at');
      return Response.json(rows);
    } finally {
      await prorm.close();
    }
  },
};

import { CloudflareVectorizeStore } from 'ts-prorm-orm/nosql/cloudflare-vectorize';

const vectors = new CloudflareVectorizeStore({ accountId, indexName: 'docs', apiToken });
await vectors.connect();

await vectors.upsert([{ id: '1', values: embedding, metadata: { url: '/a' } }]);
const { matches } = await vectors.query(queryEmbedding, { topK: 3, returnMetadata: 'all' });

import { CloudflareQueuesStore } from 'ts-prorm-orm/nosql/cloudflare-queues';

const queue = new CloudflareQueuesStore({
  accountId: process.env.CF_ACCOUNT_ID,
  queueId: process.env.CF_QUEUE_ID,
  apiToken: process.env.CF_API_TOKEN,
});
await queue.connect();

await queue.send({ orderId: 7 });

const { messages } = await queue.pull({ batchSize: 10 });
await queue.ack(messages.map((m) => m.lease_id));

const objects = new CloudflareDurableObjectsStore({ namespace: env.COUNTER });
await objects.connect();
await objects.fetch('room-42', new Request('https://do/increment'));