@tailor-platform/erp-kit 0.1.0 → 0.1.2

package/rules/module-development/sync-vs-async-operations.md

@@ -1,83 +0,0 @@
----
-paths:
-  - "modules/*/src/"
----
-
-# Sync vs Async Operations
-
-## Decision Criteria
-
-Choose synchronous or asynchronous execution based on:
-
-1. **Number of affected records** - How many records need processing?
-2. **Data growth trajectory** - Will the operation slow down as data grows?
-
-| Scenario                            | Approach           | Implementation              |
-| ----------------------------------- | ------------------ | --------------------------- |
-| Single record, bounded complexity   | **Synchronous**    | Inline in command           |
-| Single record, unbounded complexity | **Consider async** | Evaluate growth             |
-| Multiple records                    | **Asynchronous**   | Executor with `jobFunction` |
-
-## Growth Considerations
-
-Ask: "How does this operation scale as the system grows?"
-
-- **Bounded**: User status update (always 1 record, O(1))
-- **Bounded**: Single user permission recompute (limited by reasonable role/permission counts)
-- **Unbounded**: All users with role X (grows with user base, O(n))
-- **Unbounded**: All orders in date range (grows with transaction volume)
-
-When in doubt, monitor operation timing in production and migrate to async if latency increases.
-
-## Rationale
-
-- **Synchronous**: Acceptable when operation time is predictable and bounded
-- **Asynchronous**: Required when operation time scales with data volume
-
-## Pattern: Synchronous (Single Record)
-
-Commands that affect a single known record should execute the operation inline and return the result:
-
-```typescript
-// In command - recompute immediately
-const updatedUser = await recomputeUserPermissions(db, input.userId);
-return { userRole, user: updatedUser, auditEvent };
-```
-
-## Pattern: Asynchronous (Multiple Records)
-
-Commands that affect an unknown number of records should delegate to an executor:
-
-```typescript
-// Command just creates/deletes the record
-// Executor handles recomputation asynchronously
-```
-
-Create executors with record triggers:
-
-- `recordCreatedTrigger` - React to inserts
-- `recordDeletedTrigger` - React to deletes
-- Use `kind: "jobFunction"` for extended execution
-
-## Example: Permission Recomputation
-
-| Command                  | Affected                | Approach        |
-| ------------------------ | ----------------------- | --------------- |
-| assignRoleToUser         | 1 user                  | Sync in command |
-| revokeRoleFromUser       | 1 user                  | Sync in command |
-| assignPermissionToRole   | N users (all with role) | Async executor  |
-| revokePermissionFromRole | N users (all with role) | Async executor  |
-
-## Trade-offs
-
-**Synchronous:**
-
-- Immediate consistency
-- Simpler error handling
-- Blocks request until complete
-
-**Asynchronous:**
-
-- Eventual consistency
-- Non-blocking requests
-- Requires executor infrastructure

package/rules/sdk-best-practices/sdk-docs.md

@@ -1,14 +0,0 @@
----
-paths:
-  - "modules/*/src/db/*.ts"
-  - "modules/*/src/executor/*.ts"
-  - "modules/*/src/workflow/*.ts"
----
-
-# SDK Docs Reference
-
-Read the official Tailor SDK documentation for database models, executors:
-
-- [TailorDB Models](https://raw.githubusercontent.com/tailor-platform/sdk/refs/heads/main/packages/sdk/docs/services/tailordb.md)
-- [Executors](https://raw.githubusercontent.com/tailor-platform/sdk/refs/heads/main/packages/sdk/docs/services/executors.md)
-- [Workflow](https://raw.githubusercontent.com/tailor-platform/sdk/refs/heads/main/packages/sdk/docs/services/workflow.md)

package/src/modules/primitives/command/convertAmount.ts

@@ -1,126 +0,0 @@
-import { defineCommand } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
-import {
-  CurrencyNotFoundError,
-  ExchangeRateNotFoundError,
-  InactiveCurrencyError,
-} from "../lib/errors";
-import { permissions } from "../permissions";
-
-export interface ConvertAmountInput {
-  amount: number;
-  sourceCurrencyCode: string;
-  targetCurrencyCode: string;
-  conversionDate: string;
-}
-
-/**
- * Function: convertAmount
- *
- * Converts a monetary amount from one currency to another using the applicable
- * exchange rate for a given date. Currencies are identified by their ISO 4217
- * code (e.g., "USD", "EUR", "JPY"). The function looks up the most recent exchange
- * rate on or before the specified date. If no direct rate exists, it calculates
- * the inverse rate. Result is rounded to the target currency's decimal precision.
- */
-export const convertAmount = defineCommand(
-  permissions.convertAmount,
-  async (db: DB, input: ConvertAmountInput) => {
-    // 1. Validate source currency exists
-    const sourceCurrency = await db
-      .selectFrom("Currency")
-      .selectAll()
-      .where("code", "=", input.sourceCurrencyCode)
-      .executeTakeFirst();
-
-    if (!sourceCurrency) {
-      throw new CurrencyNotFoundError(input.sourceCurrencyCode);
-    }
-
-    // 2. Validate target currency exists
-    const targetCurrency = await db
-      .selectFrom("Currency")
-      .selectAll()
-      .where("code", "=", input.targetCurrencyCode)
-      .executeTakeFirst();
-
-    if (!targetCurrency) {
-      throw new CurrencyNotFoundError(input.targetCurrencyCode);
-    }
-
-    // 3. Validate both currencies are active
-    if (!sourceCurrency.isActive) {
-      throw new InactiveCurrencyError(input.sourceCurrencyCode);
-    }
-
-    if (!targetCurrency.isActive) {
-      throw new InactiveCurrencyError(input.targetCurrencyCode);
-    }
-
-    // 4. Same currency - return original amount
-    if (sourceCurrency.id === targetCurrency.id) {
-      return {
-        convertedAmount: input.amount,
-        exchangeRate: 1,
-        sourceCurrency,
-        targetCurrency,
-        exchangeRateRecord: null,
-      };
-    }
-
-    // 5. Find direct exchange rate (most recent on or before conversion date)
-    const conversionDate = new Date(input.conversionDate);
-    const directRate = await db
-      .selectFrom("ExchangeRate")
-      .selectAll()
-      .where("sourceCurrencyId", "=", sourceCurrency.id)
-      .where("targetCurrencyId", "=", targetCurrency.id)
-      .where("effectiveDate", "<=", conversionDate)
-      .orderBy("effectiveDate", "desc")
-      .executeTakeFirst();
-
-    let exchangeRate: number;
-    let exchangeRateRecord = null;
-
-    if (directRate) {
-      exchangeRate = directRate.rate;
-      exchangeRateRecord = directRate;
-    } else {
-      // 6. Try inverse rate
-      const inverseRate = await db
-        .selectFrom("ExchangeRate")
-        .selectAll()
-        .where("sourceCurrencyId", "=", targetCurrency.id)
-        .where("targetCurrencyId", "=", sourceCurrency.id)
-        .where("effectiveDate", "<=", conversionDate)
-        .orderBy("effectiveDate", "desc")
-        .executeTakeFirst();
-
-      if (!inverseRate) {
-        throw new ExchangeRateNotFoundError(
-          input.sourceCurrencyCode,
-          input.targetCurrencyCode,
-          input.conversionDate,
-        );
-      }
-
-      exchangeRate = 1 / inverseRate.rate;
-      exchangeRateRecord = inverseRate;
-    }
-
-    // 7. Calculate converted amount
-    const rawResult = input.amount * exchangeRate;
-
-    // 8. Round to target currency's decimal places
-    const roundingFactor = Math.pow(10, targetCurrency.decimalPlaces);
-    const convertedAmount = Math.round(rawResult * roundingFactor) / roundingFactor;
-
-    return {
-      convertedAmount,
-      exchangeRate,
-      sourceCurrency,
-      targetCurrency,
-      exchangeRateRecord,
-    };
-  },
-);