@vaharoni/devops 1.2.13 → 1.2.14

package/dist/src/target-templates/lang-variants-prisma/python/.cursor/rules/prisma-python.mdc

@@ -0,0 +1,55 @@
+---
+globs: *.prisma,*.sql
+alwaysApply: false
+---
+
+# Prisma (Python)
+
+Assume all existing prisma migrations are applied, hence never change existing migrations.
+
+NEVER reset the development database without permission.
+
+As you know, Prisma is not good at renaming, so after creating migrations automatically from schema changes always go over the migrations and make sure it captured the user intent.
+
+## Commands
+
+All prisma commands should be executed via the devopspy CLI:
+
+```bash
+./devopspy prisma <some command>
+./devopspy prisma migrate dev
+```
+
+To generate the Prisma client after schema changes:
+
+```bash
+./devopspy run db:generate
+```
+
+## DB Package
+
+The prisma schema resides in `db/prisma/schema.prisma`. To use the Prisma client from any application, add `db` as a workspace dependency in your `pyproject.toml`:
+
+```toml
+[tool.uv.sources]
+db = { workspace = true }
+```
+
+Then import as usual:
+
+```python
+from db import prisma
+```
+
+## Schema Conventions
+
+When editing Prisma schemas:
+
+- Define new models with singular PascalCase names and map them to plural snake_case table names via `@@map`.
+- All table columns should remain in snake_case using `@map` on each field when needed.
+- Default primary keys should be `String @id @default(cuid())` unless there is an explicit reason to use another strategy.
+- Add `@default(now())` + `@map("created_at")` for creation timestamps and `@default(now()) @updatedAt @map("updated_at")` for update timestamps.
+- Always create an index (`@@index`) for every relational field to keep lookups performant.
+- Prefer Prisma's default column type mapping; use `@db.*` annotations only when you truly need a non-default database type.
+- Prefer lowercase values for enums we fully control (e.g., `pending`, `completed` instead of `PENDING`, `COMPLETED`).
+- Prefer strings rather than enums for data-driven closed-lists unless the user requests otherwise.

package/dist/src/target-templates/lang-variants-prisma/python/.cursor/rules/testing-python.mdc

@@ -0,0 +1,89 @@
+---
+alwaysApply: true
+---
+
+# Testing
+
+## Running Tests
+
+**IMPORTANT**: Always use `./devopspy test` to run tests:
+
+```bash
+# Run all tests
+./devopspy test
+
+# Run tests for a specific package
+./devopspy test <project-name>
+./devopspy test my-service
+```
+
+This command:
+
+- Sets `MONOREPO_ENV=test` to use the test database (separate from development)
+- Loads the correct environment variables from `config/.env.test`
+- Ensures test isolation
+
+**Never run tests directly with `pytest`** - this will use the development database and might pollute it with test data.
+
+## Prisma Transactional Testing
+
+We use a transactional testing pattern where each test runs inside a database transaction that is automatically rolled back after the test completes. This ensures:
+
+- Complete test isolation - tests don't affect each other
+- No cleanup code needed - the rollback handles it
+- Fast tests - no need to truncate tables between tests
+
+### Setting Up Tests for a New Package
+
+1. Create a `tests/conftest.py` in your package that imports the test fixtures:
+
+```python
+from db.db_client_test import *
+```
+
+2. Ensure `db` is in your workspace dependencies in `pyproject.toml`:
+
+```toml
+[project]
+dependencies = ["db"]
+
+[tool.uv.sources]
+db = { workspace = true }
+```
+
+### Writing Tests
+
+Tests receive a `db_connection` fixture that provides a transactional database connection:
+
+```python
+import pytest
+
+@pytest.mark.asyncio
+async def test_creates_record(db_connection):
+    # This record will be rolled back after the test
+    record = await db_connection.mymodel.create(
+        data={"name": "test"}
+    )
+    
+    assert record.id is not None
+
+@pytest.mark.asyncio
+async def test_can_use_same_data(db_connection):
+    # This test gets a clean slate - the previous test's data was rolled back
+    record = await db_connection.mymodel.create(
+        data={"name": "test"}  # same name works!
+    )
+    
+    assert record.id is not None
+```
+
+### How It Works
+
+The `db_connection` fixture in `db/db_client_test.py`:
+
+- Creates a new Prisma client and connects to the database
+- Starts a transaction and yields a `TransactionProxy` to the test
+- Raises `RollbackTransaction` after the test completes to rollback all changes
+- Disconnects from the database
+
+This means each test receives an isolated transaction that is automatically rolled back.

package/dist/src/target-templates/lang-variants-prisma/python/db/db/db_client_test.py

@@ -0,0 +1,46 @@
+import pytest_asyncio
+from prisma import Prisma
+from contextlib import asynccontextmanager
+
+"""Usage:
+    Add the file tests/conftest.py with the following content:
+
+    from db.db_client_test import *
+"""
+
+# To open ipython at a particular point, do this:
+#
+# Add imports:
+#   from IPython import embed
+#   import nest_asyncio
+#
+# Insert this to the right position in the code:
+#   nest_asyncio.apply() 
+#   embed()
+
+class RollbackTransaction(Exception): pass
+
+class TransactionProxy:
+    def __init__(self, transaction):
+        self._transaction = transaction
+    
+    def __getattr__(self, name):
+        return getattr(self._transaction, name)
+
+    @asynccontextmanager
+    async def tx(self):
+        yield self._transaction
+
+@pytest_asyncio.fixture(scope='function')
+async def db_connection():
+    db = Prisma()
+    await db.connect()
+    try:
+        async with db.tx() as transaction:
+            tx = TransactionProxy(transaction)
+            yield tx
+            raise RollbackTransaction('rollback')
+    except RollbackTransaction:
+        pass
+    finally:
+        await db.disconnect()

package/dist/src/target-templates/lang-variants-prisma/python/db/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "db"
+version = "0.1.0"
+description = ""
+authors = []
+requires-python = ">=3.12"
+dependencies = ["prisma (>=0.15.0,<0.16.0)"]
+
+[tool.devops.scripts]
+generate = "prisma generate --generator python-client"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

package/dist/src/target-templates/lang-variants-prisma/typescript/.cursor/rules/prisma-typescript.mdc

@@ -0,0 +1,54 @@
+---
+globs: *.prisma,*.sql
+alwaysApply: false
+---
+
+# Prisma
+
+Assume all existing prisma migrations are applied, hence never change existing migrations.
+
+NEVER reset the development database without permission.
+
+As you know, Prisma is not good at renaming, so after creating migrations automatically from schema changes always go over the migrations and make sure it captured the user intent.
+
+## Commands
+
+All prisma commands should be executed via the devops CLI:
+
+```bash
+./devops prisma <some command>
+./devops prisma migrate dev
+```
+
+To generate the Prisma client after schema changes:
+
+```bash
+./devops run db:generate
+```
+
+## DB Package
+
+The prisma schema resides in `db/prisma/schema.prisma`. To connect to prisma from any application, add `"db": "workspace:*"` to the dependency list of the app's `package.json`. Then import as usual:
+
+```typescript
+import { prisma } from "db";
+```
+
+To import Prisma types corresponding to tables, import from the prisma client package:
+
+```typescript
+import { type SomeType } from "@prisma/client";
+```
+
+## Schema Conventions
+
+When editing Prisma schemas:
+
+- Define new models with singular PascalCase names and map them to plural snake_case table names via `@@map`.
+- All table columns should remain in snake_case using `@map` on each field when needed.
+- Default primary keys should be `String @id @default(cuid())` unless there is an explicit reason to use another strategy.
+- Add `@default(now())` + `@map("created_at")` for creation timestamps and `@default(now()) @updatedAt @map("updated_at")` for update timestamps.
+- Always create an index (`@@index`) for every relational field to keep lookups performant.
+- Prefer Prisma's default column type mapping; use `@db.*` annotations only when you truly need a non-default database type.
+- Prefer lowercase values for enums we fully control (e.g., `pending`, `completed` instead of `PENDING`, `COMPLETED`).
+- Prefer strings rather than enums for data-driven closed-lists unless the user requests otherwise.

package/dist/src/target-templates/lang-variants-prisma/typescript/.cursor/rules/testing-typescript.mdc

@@ -0,0 +1,103 @@
+---
+alwaysApply: true
+---
+
+# Testing
+
+## Running Tests
+
+**IMPORTANT**: Always use `./devops test` to run tests:
+
+```bash
+# Run all tests
+./devops test
+
+# Run tests for a specific package
+./devops test <project-name>
+./devops test @local/my-service
+```
+
+This command:
+
+- Sets `MONOREPO_ENV=test` to use the test database (separate from development)
+- Loads the correct environment variables from `config/.env.test`
+- Ensures test isolation
+
+**Never run tests directly with `bun test` or `vitest`** - this will use the development database and might pollute it with test data if the transactional testing (see below) is not properly configured.
+
+## Prisma Transactional Testing
+
+We use a transactional testing pattern where each test runs inside a database transaction that is automatically rolled back after the test completes. This ensures:
+
+- Complete test isolation - tests don't affect each other
+- No cleanup code needed - the rollback handles it
+- Fast tests - no need to truncate tables between tests
+
+### Setting Up Tests for a New Package
+
+1. Add vitest as a dev dependency and a test script to your `package.json`:
+
+```json
+{
+  "devDependencies": {
+    "vitest": "^3.0.9"
+  },
+  "scripts": {
+    "test": "vitest"
+  }
+}
+```
+
+2. Create a `vitest.config.ts` in your package root:
+
+```typescript
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    setupFiles: ["../../db/prisma-setup-vitest.ts"], // adjust path based on package location
+  },
+});
+```
+
+3. Ensure `"db": "workspace:*"` is in your dependencies if you use Prisma.
+
+### Writing Tests
+
+Tests can create database records freely - they will be rolled back automatically:
+
+```typescript
+import { describe, it, expect } from "vitest";
+import { prisma } from "db";
+
+describe("MyFeature", () => {
+  it("creates a record", async () => {
+    // This record will be rolled back after the test
+    const record = await prisma.myModel.create({
+      data: { name: "test" },
+    });
+
+    expect(record.id).toBeDefined();
+  });
+
+  it("can use the same data", async () => {
+    // This test gets a clean slate - the previous test's data was rolled back
+    const record = await prisma.myModel.create({
+      data: { name: "test" }, // same name works!
+    });
+
+    expect(record.id).toBeDefined();
+  });
+});
+```
+
+### How It Works
+
+The setup in `db/prisma-setup-vitest.ts` and `db/db-client-test.ts`:
+
+- Creates a transactional Prisma client with `$begin()` and `$rollback()` methods
+- Stores it in `globalThis.prismaGlobal` (same singleton used by `db/db-client.ts`)
+- Mocks the `"db"` module so all imports get the transactional client
+- Wraps each test in `beforeEach`/`afterEach` hooks that start and rollback transactions
+
+This means all code importing `prisma` from `"db"` - including services being tested - uses the same transactional client.

package/dist/src/target-templates/lang-variants-prisma/typescript/db/db-client-test.ts

@@ -0,0 +1,142 @@
+// This code is used in db/prisma-setup-vitest.ts to run test code in the context of a rollbacked transaction.
+// It is an improvement of:
+//    https://github.com/prisma/prisma-client-extensions/tree/main/callback-free-itx
+//
+// The main idea is to return a single client object that knows whether a transaction is active.
+// If a transaction is active, it routes all calls to that transaction client.
+// If no transaction is active, it routes all calls to the original client.
+// To activate a transaction, use $begin().
+//
+// See:
+//    https://github.com/prisma/prisma/issues/12458
+//    https://github.com/prisma/prisma-client-extensions/pull/52
+//    https://www.prisma.io/docs/orm/more/help-and-troubleshooting/help-articles/nextjs-prisma-client-dev-practices
+//
+import { Prisma, PrismaClient } from '@prisma/client';
+
+const ROLLBACK = { [Symbol.for('prisma.client.extension.rollback')]: true };
+
+export const prismaClientSingleton = () => {
+  let _txClient: FlatTransactionClient | null = null;
+  const prismaClientOptions = process.env['PRISMA_DEBUG']
+    ? { log: ['query' as const] }
+    : undefined;
+
+  const extendedClient = new PrismaClient(prismaClientOptions).$extends({
+    client: {
+      async $begin() {
+        const prisma = Prisma.getExtensionContext(this);
+        let setTxClient: (txClient: Prisma.TransactionClient) => void;
+        let commit: () => void;
+        let rollback: () => void;
+
+        // a promise for getting the tx inner client
+        const txClient = new Promise<Prisma.TransactionClient>((res) => {
+          setTxClient = (txClient) => res(txClient);
+        });
+
+        // a promise for controlling the transaction
+        const txPromise = new Promise((_res, _rej) => {
+          commit = () => _res(undefined);
+          rollback = () => _rej(ROLLBACK);
+        });
+
+        // opening a transaction to control externally
+        if (
+          '$transaction' in prisma &&
+          typeof prisma.$transaction === 'function'
+        ) {
+          // [AA] Note the change from the github repo to actually make rollbacks work
+          const tx = prisma
+            .$transaction((txClient: unknown) => {
+              setTxClient(txClient as unknown as Prisma.TransactionClient);
+              return txPromise;
+            })
+            .catch((e: unknown) => {
+              if (e === ROLLBACK) return;
+              throw e;
+            });
+
+          // return a proxy TransactionClient with `$commit` and `$rollback` methods
+          _txClient = new Proxy(await txClient, {
+            get(target, prop) {
+              if (prop === '$commit') {
+                return () => {
+                  _txClient = null;
+                  commit();
+                  return tx;
+                };
+              }
+              if (prop === '$rollback') {
+                return () => {
+                  _txClient = null;
+                  rollback();
+                  return tx;
+                };
+              }
+              if (prop === '$transaction') {
+                return async (fn: CallableFunction) => {
+                  return fn(target);
+                };
+              }
+              return target[prop as keyof typeof target];
+            },
+          }) as FlatTransactionClient;
+
+          return _txClient;
+        }
+
+        throw new Error('Transactions are not supported by this client');
+      },
+    },
+  });
+
+  /* eslint-disable */
+  // @ts-ignore
+  const client = new Proxy(extendedClient, {
+    get(_target, prop) {
+      if (_txClient) {
+        return _txClient[prop as keyof typeof _txClient];
+      } else {
+        return extendedClient[prop as keyof typeof extendedClient];
+      }
+    },
+  });
+  /* eslint-enable */
+
+  return client as unknown as ExtendedTransactionClient | FlatTransactionClient;
+};
+
+// Use the same global singleton key as db-client.ts (prismaGlobal)
+// This ensures all code importing from "db" uses the same transactional client
+declare global {
+  // eslint-disable-next-line no-var
+  var prismaGlobal:
+    | ExtendedTransactionClient
+    | FlatTransactionClient
+    | undefined;
+}
+
+export type ExtendedTransactionClient = Prisma.TransactionClient & {
+  $begin: () => Promise<FlatTransactionClient>;
+};
+
+export type FlatTransactionClient = Prisma.TransactionClient & {
+  $commit: () => Promise<void>;
+  $rollback: () => Promise<void>;
+};
+
+const prisma: ExtendedTransactionClient | FlatTransactionClient =
+  globalThis.prismaGlobal ?? prismaClientSingleton();
+
+globalThis.prismaGlobal = prisma;
+
+export { prisma };
+
+export async function startTx() {
+  await (prisma as ExtendedTransactionClient).$begin();
+}
+
+export async function rollbackTx() {
+  await (prisma as FlatTransactionClient).$rollback();
+}

package/dist/src/target-templates/lang-variants-prisma/typescript/db/db-client.ts

@@ -0,0 +1,19 @@
+// See https://www.prisma.io/docs/orm/more/help-and-troubleshooting/help-articles/nextjs-prisma-client-dev-practices
+import { PrismaClient } from '@prisma/client';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var prismaGlobal: PrismaClient | undefined;
+}
+
+const prismaClientSingleton = () => {
+  return new PrismaClient();
+};
+
+const prisma = (globalThis.prismaGlobal ??
+  prismaClientSingleton()) as PrismaClient;
+
+globalThis.prismaGlobal = prisma;
+
+export { prisma };
+export * from '@prisma/client';

package/dist/src/target-templates/lang-variants-prisma/typescript/db/env.yaml

@@ -0,0 +1,4 @@
+# Prisma supports the native connection string format for PostgreSQL, MySQL, SQLite, SQL Server, MongoDB and CockroachDB.
+# See the documentation for all the connection string options: https://pris.ly/d/connection-strings
+
+- DATABASE_URL

package/dist/src/target-templates/lang-variants-prisma/typescript/db/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "db",
+  "main": "db-client.ts",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "generate": "prisma generate --generator js-client",
+    "migrate-deploy": "prisma migrate deploy"
+  },
+  "dependencies": {
+    "@prisma/client": "^6.5.0",
+    "prisma": "^6.5.0"
+  },
+  "devDependencies": {
+    "vitest": "^3.0.9"
+  }
+}

package/dist/src/target-templates/lang-variants-prisma/typescript/db/prisma/schema.prisma

@@ -0,0 +1,24 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+generator js-client {
+  provider        = "prisma-client-js"
+  previewFeatures = ["postgresqlExtensions"]
+}
+
+generator python-client {
+  provider        = "prisma-client-py"
+  previewFeatures = ["postgresqlExtensions"]
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}

package/dist/src/target-templates/lang-variants-prisma/typescript/db/prisma-setup-vitest.ts

@@ -0,0 +1,27 @@
+import { afterEach, beforeEach, vi } from 'vitest';
+import { prisma, rollbackTx, startTx } from './db-client-test';
+
+/**
+ * Usage:
+ *  Create a `vitest.config.ts` in the project's folder with the following content.
+ *  Adjust the path to the setup file based on the nesting of the project's folder.
+ 
+  import { defineConfig } from 'vitest/config'
+
+  export default defineConfig({
+    test: {
+      setupFiles: ['../../db/prisma-setup-vitest.ts']
+    },
+  })
+  
+ */
+
+vi.mock('db', () => ({ prisma }));
+
+beforeEach(async () => {
+  await startTx();
+});
+
+afterEach(async () => {
+  await rollbackTx();
+});

package/dist/src/target-templates/lang-variants-prisma/typescript/db/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../tsconfig.json"
+}

package/dist/src/target-templates/lang-variants-prisma/typescript/dml/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dml",
+  "type": "module",
+  "dependencies": {
+    "db": "workspace:*"
+  }
+}

package/dist/src/target-templates/lang-variants-prisma/typescript/dml/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../tsconfig.json"
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vaharoni/devops",
   "type": "module",
-  "version": "1.2.13",
+  "version": "1.2.14",
   "description": "Devops utility",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
     }
   },
   "scripts": {
-    "build": "tsc && cp src/cli/exec.sh dist/cli/exec.sh",
+    "build": "tsup",
     "test": "vitest run"
   },
   "repository": {
@@ -59,6 +59,7 @@
     "@types/fs-extra": "^11.0.4",
     "@types/handlebars": "^4.1.0",
     "@types/lodash": "^4.17.16",
+    "tsup": "^8.5.1",
     "vitest": "^1.6.0"
   },
   "peerDependencies": {

package/src/cli/core/exec.ts

@@ -1,11 +1,9 @@
 import { CLICommandParser, CommandExecutor, printUsageAndExit } from "../common";
-import url from "url";
 import path from "path";
 import { getWorkspace } from "../../libs/discovery";
+import { pkgRoot } from "../../pkg-root";
 
-const __file__ = url.fileURLToPath(import.meta.url);
-const __cli__ = path.join(path.dirname(__file__), "../..", "cli");
-const execShPath = path.join(__cli__, "exec.sh");
+const execShPath = path.join(pkgRoot, "cli/exec.sh");
 
 const oneLiner =
   "Executes a command after injecting env variables, either globally or in a workspace";

package/src/cli/core/run.ts

@@ -1,11 +1,9 @@
 import { CLICommandParser, printUsageAndExit } from "../common";
-import url from "url";
 import path from "path";
 import { getWorkspace } from "../../libs/discovery";
+import { pkgRoot } from "../../pkg-root";
 
-const __file__ = url.fileURLToPath(import.meta.url);
-const __cli__ = path.join(path.dirname(__file__), "../..", "cli");
-const execShPath = path.join(__cli__, "exec.sh");
+const execShPath = path.join(pkgRoot, "cli/exec.sh");
 
 const oneLiner =
   "Runs a script defined in package.json after injecting env variables";