@develit-services/ledger 0.0.1

package/dist/shared/ledger.Bl4HgQDw.mjs

@@ -0,0 +1,108 @@
+import { base } from '@develit-io/backend-sdk';
+import { relations } from 'drizzle-orm';
+import { sqliteTable, integer, text, real } from 'drizzle-orm/sqlite-core';
+import { T as TRANSACTION_STATUSES, b as TRANSACTION_TYPES, R as REFERENCE_TYPES } from './ledger.ByUO4e44.mjs';
+import '@develit-io/general-codes';
+
+const account = sqliteTable("account", {
+  ...base,
+  name: text("name").notNull(),
+  ownerId: text("owner_id").notNull(),
+  accountType: text("account_type").$type().notNull(),
+  assetType: text("asset_type").$type().notNull(),
+  currency: text("currency").$type().notNull(),
+  balanceStrategy: text("balance_strategy").$type().notNull(),
+  parentAccountId: text("parent_account_id"),
+  closedAt: integer("closed_at", { mode: "timestamp_ms" })
+});
+const accountIdentifier = sqliteTable("account_identifier", {
+  ...base,
+  kind: text("kind").$type().notNull(),
+  iban: text("iban"),
+  accountNumber: text("account_number"),
+  bankCode: text("bank_code").$type(),
+  prefix: text("prefix"),
+  swift: text("swift"),
+  cryptoAddress: text("crypto_address"),
+  label: text("label"),
+  holderName: text("holder_name").notNull(),
+  network: text("network").$type(),
+  countryCode: text("country_code").$type()
+});
+const accountIdentifierMapping = sqliteTable(
+  "account_identifier_mapping",
+  {
+    accountId: text("account_id").notNull().references(() => account.id),
+    identifierId: text("identifier_id").notNull().references(() => accountIdentifier.id)
+  }
+);
+const accountRelations = relations(account, ({ many }) => ({
+  identifiers: many(accountIdentifierMapping)
+}));
+const accountIdentifierRelations = relations(
+  accountIdentifier,
+  ({ many }) => ({
+    accountMappings: many(accountIdentifierMapping)
+  })
+);
+const accountIdentifierMappingRelations = relations(
+  accountIdentifierMapping,
+  ({ one }) => ({
+    account: one(account, {
+      fields: [accountIdentifierMapping.accountId],
+      references: [account.id]
+    }),
+    identifier: one(accountIdentifier, {
+      fields: [accountIdentifierMapping.identifierId],
+      references: [accountIdentifier.id]
+    })
+  })
+);
+
+const entry = sqliteTable("entry", {
+  ...base,
+  accountId: text("account_id").notNull(),
+  currency: text("currency").notNull(),
+  creditAmount: real("amount").notNull(),
+  debitAmount: real("debit_amount").notNull(),
+  correlationId: text("correlation_id").notNull(),
+  transactionId: text("transaction_id").notNull(),
+  status: text("status").$type().notNull(),
+  isBalanced: integer("is_balanced", { mode: "boolean" }).notNull(),
+  metadata: text("metadata", { mode: "json" }).$type().notNull(),
+  timestamp: integer("timestamp", { mode: "timestamp_ms" }).notNull()
+});
+
+const transaction = sqliteTable("transaction", {
+  ...base,
+  correlationId: text("correlation_id").notNull(),
+  // Unique ID for the transaction, used for correlation
+  // Business context
+  referenceType: text("reference_type", { enum: REFERENCE_TYPES }).$type().notNull(),
+  referenceId: text("reference_id"),
+  // business transaction ID
+  type: text("type", { enum: TRANSACTION_TYPES }).$type().notNull(),
+  description: text("description"),
+  completedAt: integer("completed_at", { mode: "timestamp_ms" }),
+  confirmationSentAt: integer("confirmation_sent_at", { mode: "timestamp_ms" }),
+  status: text("status", { enum: TRANSACTION_STATUSES }).$type().notNull(),
+  statusReason: text("status_reason"),
+  paymentId: text("payment_id"),
+  metadata: text("metadata", { mode: "json" }).$type().notNull(),
+  value: real("value"),
+  currency: text("currency").$type()
+});
+
+const schema = {
+  __proto__: null,
+  account: account,
+  accountIdentifier: accountIdentifier,
+  accountIdentifierMapping: accountIdentifierMapping,
+  accountIdentifierMappingRelations: accountIdentifierMappingRelations,
+  accountIdentifierRelations: accountIdentifierRelations,
+  accountRelations: accountRelations,
+  entry: entry,
+  transaction: transaction
+};
+
+export { account as a, accountIdentifier as b, accountIdentifierMapping as c, accountRelations as d, accountIdentifierRelations as e, accountIdentifierMappingRelations as f, entry as g, schema as s, transaction as t };

package/dist/shared/ledger.ByUO4e44.mjs

@@ -0,0 +1,285 @@
+import { COUNTRY_CODES_2, BANK_CODES, CURRENCY_CODES } from '@develit-io/general-codes';
+import { z } from 'zod';
+import { bankAccountMetadataSchema } from '@develit-io/backend-sdk';
+
+const ACCOUNT_TYPES = [
+  "INTERNAL",
+  // classic internal account managed in the system
+  "EXTERNAL",
+  // tracked external client account (e.g. at Spořka)
+  "NOSTRO",
+  // mirror bank account with third party (e.g. at Creditas)
+  "TECHNICAL",
+  // any internal account for system logic (AML, fees, ...)
+  "SETTLEMENT",
+  // account used for trade settlement
+  "FX",
+  // account serving currency conversion
+  "FEE",
+  // account for fee collection
+  "REVENUE",
+  // company profit account (e.g. from fees, FX)
+  "LOSS",
+  // loss account (e.g. FX spread, refunds)
+  "TRANSPORT",
+  // temporary parking of funds "in transit"
+  "HOLD",
+  // blocked funds (e.g. AML hold, pending settlement)
+  "SYSTEM",
+  // internal system account (e.g. provisioning, demo accounts)
+  "TEST"
+  // sandbox / test accounts
+];
+const ASSET_TYPES = [
+  "FIAT",
+  // CZK, EUR, USD…
+  "CRYPTO",
+  // BTC, ETH, USDT…
+  "TOKEN",
+  // tokenized assets – e.g. stablecoins
+  "STOCK",
+  // securities, shares
+  "COMMODITY",
+  // physical assets like gold, silver
+  "OTHER"
+  // for specific cases
+];
+const BALANCE_STRATEGIES = ["SNAPSHOT", "COMPUTED"];
+const IDENTIFIER_KINDS = [
+  "IBAN",
+  "LOCAL_CZ",
+  "SWIFT",
+  "CRYPTO_ADDRESS"
+];
+const ENTRY_STATUSES = [
+  "PENDING",
+  "REALIZED",
+  "FAILED",
+  "CANCELED"
+];
+const TRANSACTION_STATUSES = [
+  "WAITING_FOR_PAYMENT",
+  "PAUSED",
+  "WAITING_FOR_MANUAL_PROCESSING",
+  "MATCHED",
+  "RETURNING",
+  "RETURNED",
+  "FAILED",
+  "CANCELLED",
+  "COMPLETED"
+];
+const TRANSACTION_TYPES = [
+  "CLIENT_FUND_IN",
+  "CLIENT_FUND_OUT",
+  "PROVIDER_FUND_IN",
+  "PROVIDER_FUND_OUT",
+  "EXCHANGE",
+  // maybe in future
+  "UNMATCHED",
+  "ADJUSTMENT",
+  // manual correction
+  "TRANSFER"
+  // internal transfer between accounts
+];
+const REFERENCE_TYPES = ["PAYMENT", "EXCHANGE", "ORDER"];
+const PAYMENT_CHARGE_TYPES = ["SHA", "OUR", "BEN"];
+
+const ALLOWED_TRANSACTION_FILTERS = {
+  CORRELATION_ID: "filterTransactionCorrelationId",
+  REFERENCE_TYPE: "filterTransactionReferenceType",
+  REFERENCE_ID: "filterTransactionReferenceId",
+  TYPE: "filterTransactionType",
+  FROM: "filterTransactionDateFrom",
+  TO: "filterTransactionDateTo",
+  DESCRIPTION: "filterTransactionDescription",
+  COMPLETED_AT: "filterTransactionCompletedAt",
+  STATUS: "filterTransactionStatus"
+};
+
+const PAYMENT_TYPES = ["SEPA", "SWIFT", "IFSC", "DOMESTIC"];
+const PAYMENT_STATUSES = [
+  "PREPARED",
+  "INITIALIZED",
+  "FAILED",
+  "PENDING",
+  "COMPLETED",
+  "CREATED"
+];
+const PAYMENT_DIRECTIONS = ["INCOMING", "OUTGOING"];
+const BATCH_STATUSES = [
+  "OPEN",
+  "WAITING_FOR_PROCESSING",
+  "PROCESSING",
+  "READY_TO_SIGN",
+  "PREPARED",
+  "COMPLETED",
+  "FAILED"
+];
+const COUNTRY_CODES = COUNTRY_CODES_2;
+
+const createAccountInputSchema = z.object({
+  name: z.string().min(1),
+  ownerId: z.string().min(1),
+  accountType: z.enum(ACCOUNT_TYPES),
+  assetType: z.enum(ASSET_TYPES),
+  currency: z.enum(CURRENCY_CODES),
+  balanceStrategy: z.enum(BALANCE_STRATEGIES),
+  parentAccountId: z.string().optional(),
+  countryCode: z.enum(COUNTRY_CODES).optional(),
+  identifier: z.object({
+    kind: z.enum(IDENTIFIER_KINDS),
+    iban: z.string().optional(),
+    accountNumber: z.string().optional(),
+    bankCode: z.enum(BANK_CODES).optional(),
+    prefix: z.string().optional(),
+    swift: z.string().optional(),
+    cryptoAddress: z.string().optional(),
+    label: z.string().optional(),
+    holderName: z.string().min(1)
+  }).optional()
+});
+
+const transactionMetadataSchema = z.object({
+  rejectImbalanced: z.boolean().optional(),
+  allowPartialFailure: z.boolean().optional(),
+  tags: z.array(z.string()).optional(),
+  note: z.string().optional(),
+  payment: z.object({
+    vs: z.string().optional(),
+    // variabilní symbol
+    ss: z.string().optional(),
+    // specifický symbol
+    ks: z.string().optional(),
+    // konstantní symbol
+    message: z.string().optional(),
+    // zpráva pro příjemce
+    reference: z.string().optional(),
+    // další reference
+    creditor: bankAccountMetadataSchema.optional(),
+    // příjemce
+    debtor: bankAccountMetadataSchema.optional(),
+    // plátce
+    executionDate: z.string().optional(),
+    // ISO 8601
+    currency: z.enum(CURRENCY_CODES).optional(),
+    amount: z.number().optional(),
+    paymentChargeType: z.string().optional()
+    // typ poplatku za platbu
+  }).optional()
+}).catchall(z.unknown());
+const createTransactionInputSchema = z.object({
+  correlationId: z.string().min(1),
+  referenceType: z.enum(REFERENCE_TYPES),
+  referenceId: z.string().optional(),
+  type: z.enum(TRANSACTION_TYPES),
+  description: z.string().optional(),
+  paymentId: z.string().optional(),
+  metadata: transactionMetadataSchema.optional().default({}),
+  status: z.enum(TRANSACTION_STATUSES)
+  // entries: z.array(entryInputSchema).min(1),
+});
+
+const deleteAccountInputSchema = z.object({
+  accountId: z.uuid()
+});
+
+const findAccountByIdentifierInputSchema = z.object({
+  iban: z.string().optional(),
+  accountNumber: z.string().optional(),
+  bankCode: z.enum(BANK_CODES).optional(),
+  swift: z.string().optional(),
+  cryptoAddress: z.string().optional()
+}).refine(
+  (data) => {
+    const hasIban = !!data.iban;
+    const hasAccountNumber = !!(data.accountNumber && data.bankCode);
+    const hasSwift = !!data.swift;
+    const hasCryptoAddress = !!data.cryptoAddress;
+    return hasIban || hasAccountNumber || hasSwift || hasCryptoAddress;
+  },
+  {
+    message: "At least one identifier (iban, accountNumber+bankCode, swift, or cryptoAddress) must be provided"
+  }
+);
+
+const getAccountInputSchema = z.object({
+  accountId: z.uuid()
+});
+
+const getAccountBalanceInputSchema = z.object({
+  accountId: z.uuid()
+});
+
+const getAccountIdentifierInputSchema = z.object({
+  identifierId: z.uuid()
+});
+
+const getAccountsByOwnerInputSchema = z.object({
+  ownerId: z.string().min(1)
+});
+
+const listAccountIdentifiersInputSchema = z.object({
+  accountId: z.uuid()
+});
+
+const listAccountsInputSchema = z.object({
+  ownerId: z.string().optional(),
+  accountType: z.enum(ACCOUNT_TYPES).optional(),
+  assetType: z.enum(ASSET_TYPES).optional(),
+  currency: z.enum(CURRENCY_CODES).optional(),
+  parentAccountId: z.string().optional(),
+  limit: z.number().int().min(1).max(1e3).default(100),
+  offset: z.number().int().min(0).default(0)
+});
+
+const updateAccountInputSchema = z.object({
+  accountId: z.uuid(),
+  name: z.string().min(1).optional(),
+  accountType: z.enum(ACCOUNT_TYPES).optional(),
+  assetType: z.enum(ASSET_TYPES).optional(),
+  currency: z.enum(CURRENCY_CODES).optional(),
+  balanceStrategy: z.enum(BALANCE_STRATEGIES).optional(),
+  parentAccountId: z.string().optional()
+  // todo: removed because its no longer in the account schema and the method using it does not update the account identifier which has it
+  // countryCode: z.enum(COUNTRY_CODES).optional(),
+});
+
+const updateTransactionInputSchema = z.object({
+  transactionId: z.uuid(),
+  status: z.enum(TRANSACTION_STATUSES),
+  completedAt: z.date().optional()
+});
+
+const getTransactionByIdInputSchema = z.object({
+  id: z.uuid()
+});
+
+const getTransactionsByReferenceIdInputSchema = z.object({
+  referenceType: z.enum(REFERENCE_TYPES),
+  referenceId: z.uuid()
+});
+
+const getTransactionsInputSchema = z.object({
+  page: z.number().positive(),
+  limit: z.number().positive(),
+  sort: z.object({
+    column: z.string(),
+    direction: z.enum(["asc", "desc"])
+  }),
+  [ALLOWED_TRANSACTION_FILTERS.CORRELATION_ID]: z.uuid().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.REFERENCE_TYPE]: z.enum(REFERENCE_TYPES).optional(),
+  [ALLOWED_TRANSACTION_FILTERS.REFERENCE_ID]: z.uuid().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.TYPE]: z.enum(TRANSACTION_TYPES).optional(),
+  [ALLOWED_TRANSACTION_FILTERS.DESCRIPTION]: z.string().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.FROM]: z.date().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.TO]: z.date().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.COMPLETED_AT]: z.date().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.STATUS]: z.enum(TRANSACTION_STATUSES).optional(),
+  search: z.string().optional()
+});
+
+const updateTransactionConfirmationSentAtInputSchema = z.object({
+  transactionId: z.uuid()
+});
+
+export { ACCOUNT_TYPES as A, BALANCE_STRATEGIES as B, COUNTRY_CODES as C, ENTRY_STATUSES as E, IDENTIFIER_KINDS as I, PAYMENT_CHARGE_TYPES as P, REFERENCE_TYPES as R, TRANSACTION_STATUSES as T, ASSET_TYPES as a, TRANSACTION_TYPES as b, ALLOWED_TRANSACTION_FILTERS as c, createAccountInputSchema as d, createTransactionInputSchema as e, deleteAccountInputSchema as f, findAccountByIdentifierInputSchema as g, getAccountInputSchema as h, getAccountBalanceInputSchema as i, getAccountIdentifierInputSchema as j, getAccountsByOwnerInputSchema as k, listAccountIdentifiersInputSchema as l, listAccountsInputSchema as m, updateTransactionInputSchema as n, getTransactionByIdInputSchema as o, getTransactionsByReferenceIdInputSchema as p, getTransactionsInputSchema as q, updateTransactionConfirmationSentAtInputSchema as r, PAYMENT_TYPES as s, PAYMENT_STATUSES as t, updateAccountInputSchema as u, PAYMENT_DIRECTIONS as v, BATCH_STATUSES as w };