@develit-services/ledger 0.0.1

package/dist/shared/ledger.Ce2yPDUS.d.cts

@@ -0,0 +1,18 @@
+interface LedgerServiceEnvironmentConfig {
+    d1: {
+        id: string;
+    };
+    vars: Record<string, unknown>;
+}
+interface LedgerServiceWranglerConfig {
+    project: string;
+    name: string;
+    envs: {
+        local: LedgerServiceEnvironmentConfig;
+        [key: string]: LedgerServiceEnvironmentConfig;
+    };
+}
+interface LedgerServiceEnv extends LedgerEnv {
+}
+
+export type { LedgerServiceWranglerConfig as L, LedgerServiceEnvironmentConfig as a, LedgerServiceEnv as b };

package/dist/shared/ledger.Ce2yPDUS.d.mts

@@ -0,0 +1,18 @@
+interface LedgerServiceEnvironmentConfig {
+    d1: {
+        id: string;
+    };
+    vars: Record<string, unknown>;
+}
+interface LedgerServiceWranglerConfig {
+    project: string;
+    name: string;
+    envs: {
+        local: LedgerServiceEnvironmentConfig;
+        [key: string]: LedgerServiceEnvironmentConfig;
+    };
+}
+interface LedgerServiceEnv extends LedgerEnv {
+}
+
+export type { LedgerServiceWranglerConfig as L, LedgerServiceEnvironmentConfig as a, LedgerServiceEnv as b };

package/dist/shared/ledger.Ce2yPDUS.d.ts

@@ -0,0 +1,18 @@
+interface LedgerServiceEnvironmentConfig {
+    d1: {
+        id: string;
+    };
+    vars: Record<string, unknown>;
+}
+interface LedgerServiceWranglerConfig {
+    project: string;
+    name: string;
+    envs: {
+        local: LedgerServiceEnvironmentConfig;
+        [key: string]: LedgerServiceEnvironmentConfig;
+    };
+}
+interface LedgerServiceEnv extends LedgerEnv {
+}
+
+export type { LedgerServiceWranglerConfig as L, LedgerServiceEnvironmentConfig as a, LedgerServiceEnv as b };

package/dist/shared/ledger.D1MIlhpb.cjs

@@ -0,0 +1,317 @@
+'use strict';
+
+const generalCodes = require('@develit-io/general-codes');
+const zod = require('zod');
+const backendSdk = require('@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 = generalCodes.COUNTRY_CODES_2;
+
+const createAccountInputSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  ownerId: zod.z.string().min(1),
+  accountType: zod.z.enum(ACCOUNT_TYPES),
+  assetType: zod.z.enum(ASSET_TYPES),
+  currency: zod.z.enum(generalCodes.CURRENCY_CODES),
+  balanceStrategy: zod.z.enum(BALANCE_STRATEGIES),
+  parentAccountId: zod.z.string().optional(),
+  countryCode: zod.z.enum(COUNTRY_CODES).optional(),
+  identifier: zod.z.object({
+    kind: zod.z.enum(IDENTIFIER_KINDS),
+    iban: zod.z.string().optional(),
+    accountNumber: zod.z.string().optional(),
+    bankCode: zod.z.enum(generalCodes.BANK_CODES).optional(),
+    prefix: zod.z.string().optional(),
+    swift: zod.z.string().optional(),
+    cryptoAddress: zod.z.string().optional(),
+    label: zod.z.string().optional(),
+    holderName: zod.z.string().min(1)
+  }).optional()
+});
+
+const transactionMetadataSchema = zod.z.object({
+  rejectImbalanced: zod.z.boolean().optional(),
+  allowPartialFailure: zod.z.boolean().optional(),
+  tags: zod.z.array(zod.z.string()).optional(),
+  note: zod.z.string().optional(),
+  payment: zod.z.object({
+    vs: zod.z.string().optional(),
+    // variabilní symbol
+    ss: zod.z.string().optional(),
+    // specifický symbol
+    ks: zod.z.string().optional(),
+    // konstantní symbol
+    message: zod.z.string().optional(),
+    // zpráva pro příjemce
+    reference: zod.z.string().optional(),
+    // další reference
+    creditor: backendSdk.bankAccountMetadataSchema.optional(),
+    // příjemce
+    debtor: backendSdk.bankAccountMetadataSchema.optional(),
+    // plátce
+    executionDate: zod.z.string().optional(),
+    // ISO 8601
+    currency: zod.z.enum(generalCodes.CURRENCY_CODES).optional(),
+    amount: zod.z.number().optional(),
+    paymentChargeType: zod.z.string().optional()
+    // typ poplatku za platbu
+  }).optional()
+}).catchall(zod.z.unknown());
+const createTransactionInputSchema = zod.z.object({
+  correlationId: zod.z.string().min(1),
+  referenceType: zod.z.enum(REFERENCE_TYPES),
+  referenceId: zod.z.string().optional(),
+  type: zod.z.enum(TRANSACTION_TYPES),
+  description: zod.z.string().optional(),
+  paymentId: zod.z.string().optional(),
+  metadata: transactionMetadataSchema.optional().default({}),
+  status: zod.z.enum(TRANSACTION_STATUSES)
+  // entries: z.array(entryInputSchema).min(1),
+});
+
+const deleteAccountInputSchema = zod.z.object({
+  accountId: zod.z.uuid()
+});
+
+const findAccountByIdentifierInputSchema = zod.z.object({
+  iban: zod.z.string().optional(),
+  accountNumber: zod.z.string().optional(),
+  bankCode: zod.z.enum(generalCodes.BANK_CODES).optional(),
+  swift: zod.z.string().optional(),
+  cryptoAddress: zod.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 = zod.z.object({
+  accountId: zod.z.uuid()
+});
+
+const getAccountBalanceInputSchema = zod.z.object({
+  accountId: zod.z.uuid()
+});
+
+const getAccountIdentifierInputSchema = zod.z.object({
+  identifierId: zod.z.uuid()
+});
+
+const getAccountsByOwnerInputSchema = zod.z.object({
+  ownerId: zod.z.string().min(1)
+});
+
+const listAccountIdentifiersInputSchema = zod.z.object({
+  accountId: zod.z.uuid()
+});
+
+const listAccountsInputSchema = zod.z.object({
+  ownerId: zod.z.string().optional(),
+  accountType: zod.z.enum(ACCOUNT_TYPES).optional(),
+  assetType: zod.z.enum(ASSET_TYPES).optional(),
+  currency: zod.z.enum(generalCodes.CURRENCY_CODES).optional(),
+  parentAccountId: zod.z.string().optional(),
+  limit: zod.z.number().int().min(1).max(1e3).default(100),
+  offset: zod.z.number().int().min(0).default(0)
+});
+
+const updateAccountInputSchema = zod.z.object({
+  accountId: zod.z.uuid(),
+  name: zod.z.string().min(1).optional(),
+  accountType: zod.z.enum(ACCOUNT_TYPES).optional(),
+  assetType: zod.z.enum(ASSET_TYPES).optional(),
+  currency: zod.z.enum(generalCodes.CURRENCY_CODES).optional(),
+  balanceStrategy: zod.z.enum(BALANCE_STRATEGIES).optional(),
+  parentAccountId: zod.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 = zod.z.object({
+  transactionId: zod.z.uuid(),
+  status: zod.z.enum(TRANSACTION_STATUSES),
+  completedAt: zod.z.date().optional()
+});
+
+const getTransactionByIdInputSchema = zod.z.object({
+  id: zod.z.uuid()
+});
+
+const getTransactionsByReferenceIdInputSchema = zod.z.object({
+  referenceType: zod.z.enum(REFERENCE_TYPES),
+  referenceId: zod.z.uuid()
+});
+
+const getTransactionsInputSchema = zod.z.object({
+  page: zod.z.number().positive(),
+  limit: zod.z.number().positive(),
+  sort: zod.z.object({
+    column: zod.z.string(),
+    direction: zod.z.enum(["asc", "desc"])
+  }),
+  [ALLOWED_TRANSACTION_FILTERS.CORRELATION_ID]: zod.z.uuid().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.REFERENCE_TYPE]: zod.z.enum(REFERENCE_TYPES).optional(),
+  [ALLOWED_TRANSACTION_FILTERS.REFERENCE_ID]: zod.z.uuid().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.TYPE]: zod.z.enum(TRANSACTION_TYPES).optional(),
+  [ALLOWED_TRANSACTION_FILTERS.DESCRIPTION]: zod.z.string().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.FROM]: zod.z.date().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.TO]: zod.z.date().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.COMPLETED_AT]: zod.z.date().optional(),
+  [ALLOWED_TRANSACTION_FILTERS.STATUS]: zod.z.enum(TRANSACTION_STATUSES).optional(),
+  search: zod.z.string().optional()
+});
+
+const updateTransactionConfirmationSentAtInputSchema = zod.z.object({
+  transactionId: zod.z.uuid()
+});
+
+exports.ACCOUNT_TYPES = ACCOUNT_TYPES;
+exports.ALLOWED_TRANSACTION_FILTERS = ALLOWED_TRANSACTION_FILTERS;
+exports.ASSET_TYPES = ASSET_TYPES;
+exports.BALANCE_STRATEGIES = BALANCE_STRATEGIES;
+exports.BATCH_STATUSES = BATCH_STATUSES;
+exports.COUNTRY_CODES = COUNTRY_CODES;
+exports.ENTRY_STATUSES = ENTRY_STATUSES;
+exports.IDENTIFIER_KINDS = IDENTIFIER_KINDS;
+exports.PAYMENT_CHARGE_TYPES = PAYMENT_CHARGE_TYPES;
+exports.PAYMENT_DIRECTIONS = PAYMENT_DIRECTIONS;
+exports.PAYMENT_STATUSES = PAYMENT_STATUSES;
+exports.PAYMENT_TYPES = PAYMENT_TYPES;
+exports.REFERENCE_TYPES = REFERENCE_TYPES;
+exports.TRANSACTION_STATUSES = TRANSACTION_STATUSES;
+exports.TRANSACTION_TYPES = TRANSACTION_TYPES;
+exports.createAccountInputSchema = createAccountInputSchema;
+exports.createTransactionInputSchema = createTransactionInputSchema;
+exports.deleteAccountInputSchema = deleteAccountInputSchema;
+exports.findAccountByIdentifierInputSchema = findAccountByIdentifierInputSchema;
+exports.getAccountBalanceInputSchema = getAccountBalanceInputSchema;
+exports.getAccountIdentifierInputSchema = getAccountIdentifierInputSchema;
+exports.getAccountInputSchema = getAccountInputSchema;
+exports.getAccountsByOwnerInputSchema = getAccountsByOwnerInputSchema;
+exports.getTransactionByIdInputSchema = getTransactionByIdInputSchema;
+exports.getTransactionsByReferenceIdInputSchema = getTransactionsByReferenceIdInputSchema;
+exports.getTransactionsInputSchema = getTransactionsInputSchema;
+exports.listAccountIdentifiersInputSchema = listAccountIdentifiersInputSchema;
+exports.listAccountsInputSchema = listAccountsInputSchema;
+exports.updateAccountInputSchema = updateAccountInputSchema;
+exports.updateTransactionConfirmationSentAtInputSchema = updateTransactionConfirmationSentAtInputSchema;
+exports.updateTransactionInputSchema = updateTransactionInputSchema;

package/dist/shared/ledger.DGu3Pj-Y.cjs

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