@deboxsoft/accounting-api - npm Package Compare versions

Comparing version 0.1.0-alpha.48 to 0.1.0-alpha.49

index.cjs.js

@@ -5,82 +5,120 @@ 'use strict';
 
-var sh = require('@deboxsoft/zod');
+var z = require('@deboxsoft/zod');
 var moduleCore = require('@deboxsoft/module-core');
 
-const accountSchema = sh.object({
-  code: sh.string().nonempty(),
-  name: sh.string().nonempty(),
-  type: sh.string().nonempty(),
-  active: sh.boolean().optional(),
-  isParent: sh.boolean().optional(),
-  memo: sh.string().optional().nullable(),
-  parentId: sh.string().optional().nullable()
+const AccountSchema = z.object({
+  id: z.string().nonempty(),
+  code: z.string().nonempty(),
+  name: z.string().nonempty(),
+  type: z.string().nonempty(),
+  active: z.boolean().optional(),
+  isParent: z.boolean().optional(),
+  memo: z.string().optional(),
+  parentId: z.string().optional(),
+  division: z.string().optional()
 });
+const AccountInputSchema = AccountSchema.omit({id: true});
+const AccountTypeSchema = z.object({
+  code: z.string().nonempty(),
+  name: z.string().nonempty()
+});
 
-const numberNonNullSchema = sh.number().refinement((val) => val > 0 || val < 0, {
+const numberNonNullSchema = z.number().refinement((val) => val > 0 || val < 0, {
   code: "custom",
   message: "value must not be null"
 });
-const journalAccountSchema = sh.object({
-  accountId: sh.string().nonempty(),
+const JournalAccountSchema = z.object({
+  accountId: z.string().nonempty(),
   amount: numberNonNullSchema
 });
-const transactionSchema = sh.object({
-  date: sh.union([sh.string(), sh.date()]),
-  noJournal: sh.string().nonempty(),
-  noTransaction: sh.string().nonempty(),
-  description: sh.string().nullable().optional(),
-  type: sh.string().nonempty(),
+const TransactionStatusSchema = z['enum'](["UNAPPROVED", "APPROVED"]);
+const TransactionSchema = z.object({
+  id: z.string(),
+  date: z.union([z.string(), z.date()]),
+  noJournal: z.string().nonempty(),
+  noTransaction: z.string().nonempty(),
+  description: z.string().nullable().optional(),
+  type: z.string().nonempty(),
   total: numberNonNullSchema,
-  accountId: sh.string().nonempty(),
-  accounts: sh.array(journalAccountSchema).min(1)
+  accountId: z.string().nonempty(),
+  accounts: z.array(JournalAccountSchema).min(1),
+  status: TransactionStatusSchema
 });
+const TransactionTypeSchema = z.object({
+  code: z.string().nonempty(),
+  name: z.string().nonempty()
+});
+const TransactionInputSchema = TransactionSchema.omit({id: true});
 
-const divisionSchema = sh.object({
-  code: sh.string().nonempty(),
-  name: sh.string().nonempty()
+const DivisionSchema = z.object({
+  code: z.string().nonempty(),
+  name: z.string().nonempty()
 });
-const companySchema = sh.object({
-  name: sh.string().nonempty(),
-  address: sh.string().nonempty(),
-  divisions: sh.array(divisionSchema)
+const CompanySchema = z.object({
+  name: z.string().nonempty(),
+  address: z.string().nonempty(),
+  divisions: z.array(DivisionSchema)
 });
 
-const bankSchema = sh.string();
-const bankReconciliationSchema = sh.object({
-  accountBank: sh.string().nonempty(),
-  bank: bankSchema,
-  accountId: sh.string().nonempty(),
-  nameAccountBank: sh.string().nonempty(),
-  balance: sh.number(),
-  date: sh.union([sh.date(), sh.string()])
+const ReconcilesStatusSchema = z['enum'](["RECONCILED", "UNRECONCILED"]);
+const BankReconciliationSchema = z.object({
+  id: z.string(),
+  accountBank: z.string().nonempty(),
+  bank: z.string().nonempty(),
+  accountId: z.string().nonempty(),
+  nameAccountBank: z.string().nonempty(),
+  balance: z.number(),
+  date: z.date()
 });
-const bankStatementSchema = sh.object({
-  date: sh.union([sh.date(), sh.string().nonempty()]),
-  description: sh.string().optional().nullable(),
-  in: sh.number(),
-  out: sh.number(),
-  balance: sh.number()
+const BankStatementSchema = z.object({
+  id: z.string(),
+  bankId: z.string(),
+  date: z.date(),
+  description: z.string().optional().nullable(),
+  in: z.number(),
+  out: z.number(),
+  balance: z.number(),
+  status: ReconcilesStatusSchema
 });
-const bankStatementListSchema = sh.array(bankStatementSchema);
+const BankReconciliationHistorySchema = z.object({
+  importDate: z.date(),
+  startDate: z.date(),
+  endDate: z.date(),
+  openingBalance: z.number(),
+  lastBalance: z.number(),
+  bankId: z.string()
+});
+const BankReconciliationInputSchema = BankReconciliationSchema.omit({id: true});
+const BankStatementInputSchema = BankStatementSchema.omit({id: true, bankId: true});
 
-const inventorySchema = sh.object({
-  name: sh.string().nonempty(),
-  code: sh.string().nonempty(),
-  quantity: sh.number().min(1)
+const InventorySchema = z.object({
+  id: z.string(),
+  code: z.string().nonempty(),
+  name: z.string().nonempty(),
+  purchaseDate: z.union([z.date(), z.string()]),
+  priceItem: z.number(),
+  quantity: z.number().min(1),
+  depreciation: z.number()
 });
+const InventoryInputSchema = InventorySchema.omit({id: true});
 
-const stockTransferType = sh['enum'](["IN", "OUT"]);
-const stockSchema = sh.object({
-  date: sh.date(),
-  count: sh.number().positive(),
-  type: stockTransferType
+const StockTransferSchema = z.object({
+  id: z.string(),
+  date: z.date(),
+  count: z.number().positive(),
+  type: z['enum'](["IN", "OUT"])
 });
+const StockTransferInputSchema = StockTransferSchema.omit({id: true});
 
-const generalLedgerSchema = sh.object({
-  no: sh.string(),
-  date: sh.union([sh.date(), sh.string()]),
-  accountId: sh.string().nonempty(),
-  isCredit: sh.boolean().optional(),
-  amount: sh.number()
+const GeneralLedgerSchema = z.object({
+  id: z.string(),
+  no: z.string(),
+  date: z.union([z.date(), z.string()]),
+  accountId: z.string().nonempty(),
+  accountOppositeId: z.string().nonempty(),
+  transactionId: z.string().nonempty(),
+  isCredit: z.boolean().optional(),
+  amount: z.number()
 });
+const GeneralLedgerInputSchema = GeneralLedgerSchema.omit({id: true});
 
@@ -103,15 +141,24 @@ class AccountingError extends moduleCore.DeboxError {
 
+exports.AccountInputSchema = AccountInputSchema;
+exports.AccountSchema = AccountSchema;
+exports.AccountTypeSchema = AccountTypeSchema;
 exports.AccountingError = AccountingError;
-exports.accountSchema = accountSchema;
-exports.bankReconciliationSchema = bankReconciliationSchema;
-exports.bankSchema = bankSchema;
-exports.bankStatementListSchema = bankStatementListSchema;
-exports.bankStatementSchema = bankStatementSchema;
-exports.companySchema = companySchema;
-exports.divisionSchema = divisionSchema;
-exports.generalLedgerSchema = generalLedgerSchema;
-exports.inventorySchema = inventorySchema;
-exports.journalAccountSchema = journalAccountSchema;
-exports.stockSchema = stockSchema;
-exports.stockTransferType = stockTransferType;
-exports.transactionSchema = transactionSchema;
+exports.BankReconciliationHistorySchema = BankReconciliationHistorySchema;
+exports.BankReconciliationInputSchema = BankReconciliationInputSchema;
+exports.BankReconciliationSchema = BankReconciliationSchema;
+exports.BankStatementInputSchema = BankStatementInputSchema;
+exports.BankStatementSchema = BankStatementSchema;
+exports.CompanySchema = CompanySchema;
+exports.DivisionSchema = DivisionSchema;
+exports.GeneralLedgerInputSchema = GeneralLedgerInputSchema;
+exports.GeneralLedgerSchema = GeneralLedgerSchema;
+exports.InventoryInputSchema = InventoryInputSchema;
+exports.InventorySchema = InventorySchema;
+exports.JournalAccountSchema = JournalAccountSchema;
+exports.ReconcilesStatusSchema = ReconcilesStatusSchema;
+exports.StockTransferInputSchema = StockTransferInputSchema;
+exports.StockTransferSchema = StockTransferSchema;
+exports.TransactionInputSchema = TransactionInputSchema;
+exports.TransactionSchema = TransactionSchema;
+exports.TransactionStatusSchema = TransactionStatusSchema;
+exports.TransactionTypeSchema = TransactionTypeSchema;

index.js

@@ -1,5 +0,6 @@
-import { object, string, boolean, number, union, date, array, enum as enum$1 } from '@deboxsoft/zod';
+import { object, string, boolean, number, enum as enum$1, union, date, array } from '@deboxsoft/zod';
 import { DeboxError } from '@deboxsoft/module-core';
 
-const accountSchema = object({
+const AccountSchema = object({
+  id: string().nonempty(),
   code: string().nonempty(),
@@ -10,5 +11,11 @@ name: string().nonempty(),
   isParent: boolean().optional(),
-  memo: string().optional().nullable(),
-  parentId: string().optional().nullable()
+  memo: string().optional(),
+  parentId: string().optional(),
+  division: string().optional()
 });
+const AccountInputSchema = AccountSchema.omit({id: true});
+const AccountTypeSchema = object({
+  code: string().nonempty(),
+  name: string().nonempty()
+});
 
@@ -19,7 +26,9 @@ const numberNonNullSchema = number().refinement((val) => val > 0 || val < 0, {
 });
-const journalAccountSchema = object({
+const JournalAccountSchema = object({
   accountId: string().nonempty(),
   amount: numberNonNullSchema
 });
-const transactionSchema = object({
+const TransactionStatusSchema = enum$1(["UNAPPROVED", "APPROVED"]);
+const TransactionSchema = object({
+  id: string(),
   date: union([string(), date()]),
@@ -32,53 +41,82 @@ noJournal: string().nonempty(),
   accountId: string().nonempty(),
-  accounts: array(journalAccountSchema).min(1)
+  accounts: array(JournalAccountSchema).min(1),
+  status: TransactionStatusSchema
 });
+const TransactionTypeSchema = object({
+  code: string().nonempty(),
+  name: string().nonempty()
+});
+const TransactionInputSchema = TransactionSchema.omit({id: true});
 
-const divisionSchema = object({
+const DivisionSchema = object({
   code: string().nonempty(),
   name: string().nonempty()
 });
-const companySchema = object({
+const CompanySchema = object({
   name: string().nonempty(),
   address: string().nonempty(),
-  divisions: array(divisionSchema)
+  divisions: array(DivisionSchema)
 });
 
-const bankSchema = string();
-const bankReconciliationSchema = object({
+const ReconcilesStatusSchema = enum$1(["RECONCILED", "UNRECONCILED"]);
+const BankReconciliationSchema = object({
+  id: string(),
   accountBank: string().nonempty(),
-  bank: bankSchema,
+  bank: string().nonempty(),
   accountId: string().nonempty(),
   nameAccountBank: string().nonempty(),
   balance: number(),
-  date: union([date(), string()])
+  date: date()
 });
-const bankStatementSchema = object({
-  date: union([date(), string().nonempty()]),
+const BankStatementSchema = object({
+  id: string(),
+  bankId: string(),
+  date: date(),
   description: string().optional().nullable(),
   in: number(),
   out: number(),
-  balance: number()
+  balance: number(),
+  status: ReconcilesStatusSchema
 });
-const bankStatementListSchema = array(bankStatementSchema);
+const BankReconciliationHistorySchema = object({
+  importDate: date(),
+  startDate: date(),
+  endDate: date(),
+  openingBalance: number(),
+  lastBalance: number(),
+  bankId: string()
+});
+const BankReconciliationInputSchema = BankReconciliationSchema.omit({id: true});
+const BankStatementInputSchema = BankStatementSchema.omit({id: true, bankId: true});
 
-const inventorySchema = object({
+const InventorySchema = object({
+  id: string(),
+  code: string().nonempty(),
   name: string().nonempty(),
-  code: string().nonempty(),
-  quantity: number().min(1)
+  purchaseDate: union([date(), string()]),
+  priceItem: number(),
+  quantity: number().min(1),
+  depreciation: number()
 });
+const InventoryInputSchema = InventorySchema.omit({id: true});
 
-const stockTransferType = enum$1(["IN", "OUT"]);
-const stockSchema = object({
+const StockTransferSchema = object({
+  id: string(),
   date: date(),
   count: number().positive(),
-  type: stockTransferType
+  type: enum$1(["IN", "OUT"])
 });
+const StockTransferInputSchema = StockTransferSchema.omit({id: true});
 
-const generalLedgerSchema = object({
+const GeneralLedgerSchema = object({
+  id: string(),
   no: string(),
   date: union([date(), string()]),
   accountId: string().nonempty(),
+  accountOppositeId: string().nonempty(),
+  transactionId: string().nonempty(),
   isCredit: boolean().optional(),
   amount: number()
 });
+const GeneralLedgerInputSchema = GeneralLedgerSchema.omit({id: true});
 
@@ -101,2 +139,2 @@ class AccountingError extends DeboxError {
 
-export { AccountingError, accountSchema, bankReconciliationSchema, bankSchema, bankStatementListSchema, bankStatementSchema, companySchema, divisionSchema, generalLedgerSchema, inventorySchema, journalAccountSchema, stockSchema, stockTransferType, transactionSchema };
+export { AccountInputSchema, AccountSchema, AccountTypeSchema, AccountingError, BankReconciliationHistorySchema, BankReconciliationInputSchema, BankReconciliationSchema, BankStatementInputSchema, BankStatementSchema, CompanySchema, DivisionSchema, GeneralLedgerInputSchema, GeneralLedgerSchema, InventoryInputSchema, InventorySchema, JournalAccountSchema, ReconcilesStatusSchema, StockTransferInputSchema, StockTransferSchema, TransactionInputSchema, TransactionSchema, TransactionStatusSchema, TransactionTypeSchema };

package.json

 {
   "name": "@deboxsoft/accounting-api",
-  "version": "0.1.0-alpha.48",
+  "version": "0.1.0-alpha.49",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -34,3 +34,4 @@ "repository": {
     "version:dev": "yarn version prerelease",
-    "test": "yarn r:jest --passWithNoTests"
+    "test:ava": "yarn r:ava",
+    "test": "yarn test:ava"
   },
@@ -41,9 +42,9 @@ "publishConfig": {
   "dependencies": {
-    "@deboxsoft/module-core": "^1.5.19-0"
+    "@deboxsoft/module-core": "^1.6.2-0"
   },
   "devDependencies": {
     "@deboxsoft/zod": "^3.0.0-0",
-    "@sucrase/jest-plugin": "^2.0.0",
-    "@testing-library/jest-dom": "^5.11.9",
-    "svelte-jester": "^1.3.0"
+    "ava": "^3.15.0",
+    "ts-node": "^9.1.1",
+    "tslib": "^2.1.0"
   },
@@ -53,3 +54,4 @@ "peerDependencies": {
   },
+  "preferUnplugged": true,
   "gitHead": "b023f06cd22d9b5d6279f3930d90bbfc15186ab2"
 }

types/index.d.ts

@@ -1,4 +0,3 @@
-export * from "./types";
-export * from "./validation";
+export * from "./schema";
 export * from "./errors";
 export * from "./services";

types/services/AccountService.d.ts

@@ -1,9 +0,10 @@
-import type { Account, AccountInput, AccountType } from "../types";
+import type { Account, AccountInput, AccountType } from "../schema";
 export interface AccountService {
-    createAccount(input: AccountInput): Promise<Account>;
-    updateAccount(id: string, input: AccountInput): Promise<Account>;
-    removeAccount(id: string): Promise<boolean>;
-    findAccountById(id: string): Promise<Account | undefined>;
-    findAccount(filter?: any): Promise<Account[]>;
+    create(input: AccountInput): Promise<Account>;
+    update(id: string, input: AccountInput): Promise<boolean>;
+    remove(id: string): Promise<boolean>;
+    findById(id: string): Promise<Account | undefined>;
+    find(): Promise<Account[]>;
+    findChildAccount(parentId: string): Promise<Account[]>;
     findAccountType(): Promise<AccountType[]>;
 }

types/services/BankReconciliationService.d.ts

@@ -1,11 +0,12 @@
-import type { BankReconciliation, StatementBankInput, StatementBank, BankReconciliationInput, AccountBankImportHistory, AccountBankImportResult } from "../types";
+import type { PageCursorResult } from "@deboxsoft/module-core";
+import type { BankReconciliation, BankStatement, BankStatementInput, BankStatementParams, BankReconciliationHistoryParams, BankReconciliationInput, ImportBankReconciliationResult, BankReconciliationHistory } from "../schema";
 export interface BankReconciliationService {
-    createBankReconciliation(input: BankReconciliationInput): Promise<BankReconciliation>;
-    createStatementBankImport(bankId: string, inputs: StatementBankInput[]): Promise<AccountBankImportResult>;
-    findBankReconciliation(filter?: any): Promise<BankReconciliation[]>;
-    findBankReconciliationById(id: string): Promise<BankReconciliation | undefined>;
-    findStatementBank(bankId: string): Promise<StatementBank[]>;
-    findAccountBankImportHistory(bankId: string): Promise<AccountBankImportHistory[]>;
-    removeBankReconciliation(id: string): Promise<boolean>;
-    updateBankReconciliation(id: string, input: BankReconciliationInput): Promise<BankReconciliation>;
+    create(input: BankReconciliationInput): Promise<BankReconciliation>;
+    update(id: string, input: BankReconciliationInput): Promise<boolean>;
+    importBankReconciliation(bankId: string, inputs: BankStatementInput[]): Promise<ImportBankReconciliationResult>;
+    remove(id: string): Promise<boolean>;
+    find(): Promise<BankReconciliation[]>;
+    findById(id: string): Promise<BankReconciliation | undefined>;
+    findBankStatement(bankId: string, params?: BankStatementParams): Promise<PageCursorResult<BankStatement>>;
+    findBankReconciliationHistory(bankId: string, params?: BankReconciliationHistoryParams): Promise<PageCursorResult<BankReconciliationHistory>>;
 }

types/services/CompanyService.d.ts

@@ -1,4 +0,4 @@
-import type { Company, CompanyInput } from "../types";
+import type { Company } from "../schema";
 export interface CompanyService {
-    updateCompany(input: CompanyInput): Promise<Company>;
+    update(input: Company): Promise<Company>;
     getCompany(): Promise<Company>;
@@ -5,0 +5,0 @@ addDivision(code: string, name: string): Promise<boolean>;

types/services/GeneralLedgerService.d.ts

@@ -1,4 +0,5 @@
-import type { GeneralLedger, GeneralLedgerInput } from "../types";
+import type { CollectionParams, PageCursorResult } from "@deboxsoft/module-core";
+import type { GeneralLedger } from "../schema";
 export interface GeneralLedgerService {
-    findGeneralLedger(filter?: GeneralLedgerInput): Promise<GeneralLedger[]>;
+    find: (params?: CollectionParams) => Promise<PageCursorResult<GeneralLedger>>;
 }

types/services/InventoryService.d.ts

@@ -1,8 +0,9 @@
-import type { Inventory, InventoryInput } from "../types";
+import type { PageCursorResult } from "@deboxsoft/module-core";
+import type { Inventory, InventoryInput, InventoryParams } from "../schema";
 export interface InventoryService {
-    createInventory(input: InventoryInput): Promise<Inventory>;
-    updateInventory(id: string, input: InventoryInput): Promise<Inventory>;
-    removeInventory(id: string): Promise<boolean>;
-    findInventoryById(id: string): Promise<Inventory | undefined>;
-    findInventory(filter?: any): Promise<Inventory[]>;
+    create(input: InventoryInput): Promise<Inventory>;
+    update(id: string, input: InventoryInput): Promise<boolean>;
+    remove(id: string): Promise<boolean>;
+    findById(id: string): Promise<Inventory | undefined>;
+    find(params?: InventoryParams): Promise<PageCursorResult<Inventory>>;
 }

types/services/StockTransferService.d.ts

@@ -1,10 +0,12 @@
-import type { StockTransfer, StockInput } from "../types";
+import type { PageCursorResult } from "@deboxsoft/module-core";
+import type { StockTransfer, StockTransferInput, StockTransferParams } from "../schema";
 export interface StockTransferService {
-    createStockIn(input: StockInput): Promise<StockTransfer>;
-    createStockOut(input: StockInput): Promise<StockTransfer>;
-    updateStockIn(id: string, input: StockInput): Promise<StockTransfer>;
-    updateStockOut(id: string, input: StockInput): Promise<StockTransfer>;
+    createStockIn(input: StockTransferInput): Promise<StockTransfer>;
+    createStockOut(input: StockTransferInput): Promise<StockTransfer>;
+    updateStockIn(id: string, input: StockTransferInput): Promise<boolean>;
+    updateStockOut(id: string, input: StockTransferInput): Promise<boolean>;
     removeStockTransfer(id: string): Promise<boolean>;
     findStockTransferById(id: string): Promise<StockTransfer | undefined>;
-    findStockTransfer(filter?: any): Promise<StockTransfer[]>;
+    findStockIn(params?: StockTransferParams): Promise<PageCursorResult<StockTransfer>>;
+    findStockOut(params?: StockTransferParams): Promise<PageCursorResult<StockTransfer>>;
 }

types/services/TransactionService.d.ts

@@ -1,9 +0,10 @@
-import type { Transaction, TransactionFilterInput, TransactionInput, TransactionType } from "../types";
+import type { PageCursorResult } from "@deboxsoft/module-core";
+import type { Transaction, TransactionInput, TransactionType, TransactionParams } from "../schema";
 export interface TransactionService {
-    createTransaction(input: TransactionInput): Promise<Transaction>;
-    updateTransaction(id: string, input: Partial<TransactionInput>): Promise<Transaction>;
-    removeTransaction(id: any): Promise<boolean>;
-    findTransaction(filter?: TransactionFilterInput): Promise<Transaction[]>;
-    findTransactionById(id: string): Promise<Transaction | undefined>;
+    create(input: TransactionInput): Promise<Transaction>;
+    update(id: string, input: Partial<TransactionInput>): Promise<boolean>;
+    remove(id: any): Promise<boolean>;
+    find(params?: TransactionParams): Promise<PageCursorResult<Transaction>>;
+    findById(id: string): Promise<Transaction | undefined>;
     findTransactionType(): Promise<TransactionType[]>;
 }

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Lines of code

913

increased by3.51%

Worsened metrics

Total package byte prevSize

33257

decreased by-5.71%

Number of package files

25

decreased by-7.41%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Added@deboxsoft/module-core@1.6.2-7(transitive)

• + Addedbase64-js@1.5.1(transitive)

• + Addedbson@4.7.2(transitive)

• + Addedbuffer@5.7.1(transitive)

• + Addedieee754@1.2.1(transitive)

• - Removed@deboxsoft/module-core@1.6.1(transitive)

• Updated@deboxsoft/module-core@^1.6.2-0