kasperdokter/bigcapital
1
0
Fork 0
Code Activity

feat(sdk): add OpenAPI export script and TypeScript SDK package

Browse Source 
- Add export-openapi.ts script for server OpenAPI spec export
- Add shared/sdk-ts package with generated API clients (accounts, bills, customers, vendors, etc.)
- Update Customers and Vendors controllers
- Update ReportsEventsTracker
- Update .gitignore, package.json, and pnpm-lock

Made-with: Cursor
This commit is contained in:
Ahmed Bouhuolia
2026-03-03 23:26:24 +02:00
parent b81fcdfbd8
commit e3c55c5d6f
49 changed files with 104701 additions and 13277 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+3
View File
@@ -8,3 +8,6 @@ node_modules/
test-results/
.qodo
.pnpm-store
package.json
+2 -1
View File
@@ -22,7 +22,8 @@
"system:migrate:latest": "lerna run cli:system:migrate:latest --scope \"@bigcapital/server\"",
"tenants:migrate:latest": "lerna run cli:tenants:migrate:latest --scope \"@bigcapital/server\"",
"system:seed:latest": "lerna run cli:system:seed:latest --scope \"@bigcapital/server\"",
"tenants:seed:latest": "lerna run cli:tenants:seed:latest --scope \"@bigcapital/server\""
"tenants:seed:latest": "lerna run cli:tenants:seed:latest --scope \"@bigcapital/server\"",
"generate:sdk-types": "lerna run openapi:export --scope \"@bigcapital/server\" && lerna run generate --scope \"@bigcapital/sdk-ts\" && lerna run build --scope \"@bigcapital/sdk-ts\""
},
"devDependencies": {
"@commitlint/cli": "^17.4.2",
packages/server/package.json
+5 -3
View File
@@ -27,15 +27,17 @@
"cli:tenants:migrate:rollback": "ts-node -r tsconfig-paths/register src/cli.ts tenants:migrate:rollback",
"cli:tenants:migrate:make": "ts-node -r tsconfig-paths/register src/cli.ts tenants:migrate:make",
"cli:tenants:list": "ts-node -r tsconfig-paths/register src/cli.ts tenants:list",
"openapi:export": "ts-node -r tsconfig-paths/register scripts/export-openapi.ts",
"cli:system:seed:latest": "ts-node -r tsconfig-paths/register src/cli.ts system:seed:latest",
"cli:tenants:seed:latest": "ts-node -r tsconfig-paths/register src/cli.ts tenants:seed:latest"
},
"dependencies": {
"@aws-sdk/client-s3": "^3.576.0",
"@aws-sdk/s3-request-presigner": "^3.583.0",
"@bigcapital/email-components": "*",
"@bigcapital/pdf-templates": "*",
"@bigcapital/utils": "*",
"@bigcapital/email-components": "workspace:*",
"@bigcapital/pdf-templates": "workspace:*",
"@bigcapital/sdk-ts": "workspace:*",
"@bigcapital/utils": "workspace:*",
"@casl/ability": "^5.4.3",
"@lemonsqueezy/lemonsqueezy.js": "^2.2.0",
"@liaoliaots/nestjs-redis": "^10.0.0",
packages/server/scripts/export-openapi.ts
+46
View File
@@ -0,0 +1,46 @@
/**
* Exports the OpenAPI document from the NestJS app to shared/sdk-ts/openapi.json.
* Run from packages/server: pnpm run openapi:export
*/
/// <reference path="../src/common/types/Objection.d.ts" />
import { NestFactory } from '@nestjs/core';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
import { ClsMiddleware } from 'nestjs-cls';
import * as path from 'path';
import * as fs from 'fs';
import '@/utils/moment-mysql';
import { AppModule } from '@/modules/App/App.module';
import { NestExpressApplication } from '@nestjs/platform-express';
async function exportOpenApi() {
global.__public_dirname = path.join(__dirname, '..', 'public');
global.__static_dirname = path.join(__dirname, '..', 'static');
global.__views_dirname = path.join(global.__static_dirname, '/views');
global.__images_dirname = path.join(global.__static_dirname, '/images');
const app = await NestFactory.create<NestExpressApplication>(AppModule, {
rawBody: true,
});
app.set('query parser', 'extended');
app.setGlobalPrefix('/api');
app.use(new ClsMiddleware({}).use);
const config = new DocumentBuilder()
.setTitle('Bigcapital')
.setDescription('Financial accounting software')
.setVersion('1.0')
.build();
const document = SwaggerModule.createDocument(app, config);
await app.close();
const outputPath = path.resolve(__dirname, '../../../shared/sdk-ts/openapi.json');
fs.mkdirSync(path.dirname(outputPath), { recursive: true });
fs.writeFileSync(outputPath, JSON.stringify(document, null, 2), 'utf-8');
console.log(`OpenAPI spec written to ${outputPath}`);
}
exportOpenApi().catch((err) => {
console.error(err);
process.exit(1);
});
packages/server/src/modules/Customers/Customers.controller.ts
+1
View File
@@ -36,6 +36,7 @@ import { CustomerAction } from './types/Customers.types';
@Controller('customers')
@ApiTags('Customers')
@ApiExtraModels(CustomerResponseDto)
@ApiExtraModels(ValidateBulkDeleteCustomersResponseDto)
@ApiCommonHeaders()
@UseGuards(AuthorizationGuard, PermissionGuard)
export class CustomersController {
packages/server/src/modules/EventsTracker/events/ReportsEventsTracker.ts
+15 -15
View File
@@ -25,7 +25,7 @@ export class ReportsEventsTracker {
constructor(private readonly posthog: EventTrackerService) {}
@OnEvent(events.reports.onBalanceSheetViewed)
handleTrackBalanceSheetViewedEvent({ tenantId }: ReportsEvents) {
handleTrackBalanceSheetViewedEvent() {
this.posthog.trackEvent({
event: BALANCE_SHEET_VIEWED,
properties: {},
@@ -33,7 +33,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onTrialBalanceSheetView)
handleTrackTrialBalanceSheetViewedEvent({ tenantId }: ReportsEvents) {
handleTrackTrialBalanceSheetViewedEvent() {
this.posthog.trackEvent({
event: TRIAL_BALANCE_SHEET_VIEWED,
properties: {},
@@ -41,7 +41,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onProfitLossSheetViewed)
handleTrackProfitLossSheetViewedEvent({ tenantId }: ReportsEvents) {
handleTrackProfitLossSheetViewedEvent() {
this.posthog.trackEvent({
event: PROFIT_LOSS_SHEET_VIEWED,
properties: {},
@@ -49,7 +49,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onCashflowStatementViewed)
handleTrackCashflowStatementViewedEvent({ tenantId }: ReportsEvents) {
handleTrackCashflowStatementViewedEvent() {
this.posthog.trackEvent({
event: CASHFLOW_STATEMENT_VIEWED,
properties: {},
@@ -57,7 +57,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onGeneralLedgerViewed)
handleTrackGeneralLedgerViewedEvent({ tenantId }: ReportsEvents) {
handleTrackGeneralLedgerViewedEvent() {
this.posthog.trackEvent({
event: GENERAL_LEDGER_VIEWED,
properties: {},
@@ -65,7 +65,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onJournalViewed)
handleTrackJournalViewedEvent({ tenantId }: ReportsEvents) {
handleTrackJournalViewedEvent() {
this.posthog.trackEvent({
event: JOURNAL_VIEWED,
properties: {},
@@ -73,7 +73,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onReceivableAgingViewed)
handleTrackReceivableAgingViewedEvent({ tenantId }: ReportsEvents) {
handleTrackReceivableAgingViewedEvent() {
this.posthog.trackEvent({
event: RECEIVABLE_AGING_VIEWED,
properties: {},
@@ -81,7 +81,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onPayableAgingViewed)
handleTrackPayableAgingViewedEvent({ tenantId }: ReportsEvents) {
handleTrackPayableAgingViewedEvent() {
this.posthog.trackEvent({
event: PAYABLE_AGING_VIEWED,
properties: {},
@@ -89,7 +89,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onCustomerBalanceSummaryViewed)
handleTrackCustomerBalanceSummaryViewedEvent({ tenantId }: ReportsEvents) {
handleTrackCustomerBalanceSummaryViewedEvent() {
this.posthog.trackEvent({
event: CUSTOMER_BALANCE_SUMMARY_VIEWED,
properties: {},
@@ -97,7 +97,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onVendorBalanceSummaryViewed)
handleTrackVendorBalanceSummaryViewedEvent({ tenantId }: ReportsEvents) {
handleTrackVendorBalanceSummaryViewedEvent() {
this.posthog.trackEvent({
event: VENDOR_BALANCE_SUMMARY_VIEWED,
properties: {},
@@ -105,7 +105,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onInventoryValuationViewed)
handleTrackInventoryValuationViewedEvent({ tenantId }: ReportsEvents) {
handleTrackInventoryValuationViewedEvent() {
this.posthog.trackEvent({
event: INVENTORY_VALUATION_VIEWED,
properties: {},
@@ -113,7 +113,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onCustomerTransactionsViewed)
handleTrackCustomerTransactionsViewedEvent({ tenantId }: ReportsEvents) {
handleTrackCustomerTransactionsViewedEvent() {
this.posthog.trackEvent({
event: CUSTOMER_TRANSACTIONS_VIEWED,
properties: {},
@@ -121,7 +121,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onVendorTransactionsViewed)
handleTrackVendorTransactionsViewedEvent({ tenantId }: ReportsEvents) {
handleTrackVendorTransactionsViewedEvent() {
this.posthog.trackEvent({
event: VENDOR_TRANSACTIONS_VIEWED,
properties: {},
@@ -129,7 +129,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onSalesByItemViewed)
handleTrackSalesByItemViewedEvent({ tenantId }: ReportsEvents) {
handleTrackSalesByItemViewedEvent() {
this.posthog.trackEvent({
event: SALES_BY_ITEM_VIEWED,
properties: {},
@@ -137,7 +137,7 @@ export class ReportsEventsTracker {
}
@OnEvent(events.reports.onPurchasesByItemViewed)
handleTrackPurchasesByItemViewedEvent({ tenantId }: ReportsEvents) {
handleTrackPurchasesByItemViewedEvent() {
this.posthog.trackEvent({
event: PURCHASES_BY_ITEM_VIEWED,
properties: {},
packages/server/src/modules/Vendors/Vendors.controller.ts
+2
View File
@@ -12,6 +12,7 @@ import {
import { VendorsApplication } from './VendorsApplication.service';
import { VendorOpeningBalanceEditDto } from './dtos/VendorOpeningBalanceEdit.dto';
import {
ApiExtraModels,
ApiOperation,
ApiResponse,
ApiTags,
@@ -33,6 +34,7 @@ import { VendorAction } from '../Customers/types/Customers.types';
@Controller('vendors')
@ApiTags('Vendors')
@ApiExtraModels(ValidateBulkDeleteVendorsResponseDto)
@ApiCommonHeaders()
@UseGuards(AuthorizationGuard, PermissionGuard)
export class VendorsController {
pnpm-lock.yaml
Generated
+16511 -13257
View File
File diff suppressed because it is too large Load Diff
shared/sdk-ts/.gitignore
+1
View File
@@ -0,0 +1 @@
/dist
shared/sdk-ts/openapi.json
+45984
View File
File diff suppressed because it is too large Load Diff
shared/sdk-ts/package.json
+32
View File
@@ -0,0 +1,32 @@
{
"name": "@bigcapital/sdk-ts",
"version": "1.0.0",
"description": "TypeScript types generated from the Bigcapital API OpenAPI/Swagger spec",
"main": "./dist/index.js",
"module": "./dist/index.mjs",
"types": "./dist/index.d.ts",
"exports": {
".": {
"types": "./dist/index.d.ts",
"require": "./dist/index.js",
"import": "./dist/index.mjs"
}
},
"scripts": {
"generate": "node -e \"if(!require('fs').existsSync('./openapi.json')){console.error('\\n openapi.json not found. Run from repo root: pnpm run generate:sdk-types\\n'); process.exit(1)}\" && npx openapi-typescript ./openapi.json -o ./src/schema.ts",
"build:cjs": "tsup src/index.ts --format cjs --dts --sourcemap",
"build:esm": "tsup src/index.ts --format esm --dts --sourcemap",
"build": "npm run build:cjs && npm run build:esm",
"dev": "npm run build -- --watch"
},
"author": "",
"license": "ISC",
"dependencies": {
"openapi-typescript-fetch": "^2.2.1"
},
"devDependencies": {
"openapi-typescript": "^7.0.0",
"tsup": "^8.3.0",
"typescript": "^5.1.3"
}
}
shared/sdk-ts/src/accounts.ts
+131
View File
@@ -0,0 +1,131 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const ACCOUNTS_ROUTES = {
LIST: '/api/accounts',
BY_ID: '/api/accounts/{id}',
TYPES: '/api/accounts/types',
TRANSACTIONS: '/api/accounts/transactions',
BULK_DELETE: '/api/accounts/bulk-delete',
VALIDATE_BULK_DELETE: '/api/accounts/validate-bulk-delete',
ACTIVATE: '/api/accounts/{id}/activate',
INACTIVATE: '/api/accounts/{id}/inactivate',
} as const satisfies Record<string, keyof paths>;
type GetAccounts = paths[typeof ACCOUNTS_ROUTES.LIST]['get'];
type GetAccount = paths[typeof ACCOUNTS_ROUTES.BY_ID]['get'];
type GetAccountTypes = paths[typeof ACCOUNTS_ROUTES.TYPES]['get'];
type GetAccountTransactions = paths[typeof ACCOUNTS_ROUTES.TRANSACTIONS]['get'];
type CreateAccount = paths[typeof ACCOUNTS_ROUTES.LIST]['post'];
type EditAccount = paths[typeof ACCOUNTS_ROUTES.BY_ID]['put'];
type BulkDeleteAccounts = paths[typeof ACCOUNTS_ROUTES.BULK_DELETE]['post'];
type ValidateBulkDelete = paths[typeof ACCOUNTS_ROUTES.VALIDATE_BULK_DELETE]['post'];
export type AccountsList = GetAccounts['responses'][200]['content']['application/json'];
export type Account = GetAccount['responses'][200]['content']['application/json'];
export type AccountTypesList = GetAccountTypes['responses'][200]['content']['application/json'];
export type AccountTransactionsList = GetAccountTransactions['responses'][200]['content']['application/json'];
export type CreateAccountBody = CreateAccount['requestBody']['content']['application/json'];
export type EditAccountBody = EditAccount['requestBody']['content']['application/json'];
export type BulkDeleteBody = BulkDeleteAccounts['requestBody']['content']['application/json'];
export type ValidateBulkDeleteResponse = ValidateBulkDelete['responses'][200]['content']['application/json'];
export type GetAccountsQuery = NonNullable<GetAccounts['parameters']['query']>;
function normalizeAccountsResponse(
data: AccountsList | { accounts: AccountsList }
): AccountsList {
return Array.isArray(data) ? data : data.accounts;
}
export async function fetchAccounts(
fetcher: ApiFetcher,
query: GetAccountsQuery
): Promise<AccountsList> {
const getAccounts = fetcher.path(ACCOUNTS_ROUTES.LIST).method('get').create();
const { data } = await getAccounts(query ?? {});
return normalizeAccountsResponse(data as AccountsList | { accounts: AccountsList });
}
export async function fetchAccount(
fetcher: ApiFetcher,
id: number
): Promise<Account> {
const getAccount = fetcher.path(ACCOUNTS_ROUTES.BY_ID).method('get').create();
const { data } = await getAccount({ id });
return data;
}
export async function fetchAccountTypes(
fetcher: ApiFetcher
): Promise<AccountTypesList> {
const getAccountTypes = fetcher.path(ACCOUNTS_ROUTES.TYPES).method('get').create();
const { data } = await getAccountTypes({});
return data;
}
export async function fetchAccountTransactions(
fetcher: ApiFetcher,
id: number
): Promise<AccountTransactionsList> {
const getAccountTransactions = fetcher.path(ACCOUNTS_ROUTES.TRANSACTIONS).method('get').create();
const { data } = await getAccountTransactions({ accountId: id });
return data;
}
export async function createAccount(
fetcher: ApiFetcher,
values: CreateAccountBody
): Promise<void> {
const create = fetcher.path(ACCOUNTS_ROUTES.LIST).method('post').create();
await create(values);
}
export async function editAccount(
fetcher: ApiFetcher,
id: number,
values: EditAccountBody
): Promise<void> {
const put = fetcher.path(ACCOUNTS_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteAccount(
fetcher: ApiFetcher,
id: number
): Promise<void> {
const del = fetcher.path(ACCOUNTS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function activateAccount(
fetcher: ApiFetcher,
id: number
): Promise<void> {
const activate = fetcher.path(ACCOUNTS_ROUTES.ACTIVATE).method('post').create();
await activate({ id });
}
export async function inactivateAccount(
fetcher: ApiFetcher,
id: number
): Promise<void> {
const inactivate = fetcher.path(ACCOUNTS_ROUTES.INACTIVATE).method('post').create();
await inactivate({ id });
}
export async function bulkDeleteAccounts(
fetcher: ApiFetcher,
body: BulkDeleteBody
): Promise<void> {
const bulkDelete = fetcher.path(ACCOUNTS_ROUTES.BULK_DELETE).method('post').create();
await bulkDelete(body);
}
export async function validateBulkDeleteAccounts(
fetcher: ApiFetcher,
ids: number[]
): Promise<ValidateBulkDeleteResponse> {
const validate = fetcher.path(ACCOUNTS_ROUTES.VALIDATE_BULK_DELETE).method('post').create();
const { data } = await validate({ ids, skipUndeletable: false });
return data as ValidateBulkDeleteResponse;
}
shared/sdk-ts/src/api-keys.ts
+34
View File
@@ -0,0 +1,34 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const API_KEYS_ROUTES = {
LIST: '/api/api-keys',
GENERATE: '/api/api-keys/generate',
REVOKE: '/api/api-keys/{id}/revoke',
} as const satisfies Record<string, keyof paths>;
type GetApiKeys = paths[typeof API_KEYS_ROUTES.LIST]['get'];
type GenerateApiKey = paths[typeof API_KEYS_ROUTES.GENERATE]['post'];
type RevokeApiKey = paths[typeof API_KEYS_ROUTES.REVOKE]['put'];
export type ApiKeysList = GetApiKeys['responses'][200]['content']['application/json'];
export type GenerateApiKeyBody = GenerateApiKey['requestBody']['content']['application/json'];
export async function fetchApiKeys(fetcher: ApiFetcher): Promise<ApiKeysList> {
const get = fetcher.path(API_KEYS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function generateApiKey(
fetcher: ApiFetcher,
body: GenerateApiKeyBody
): Promise<void> {
const post = fetcher.path(API_KEYS_ROUTES.GENERATE).method('post').create();
await post(body);
}
export async function revokeApiKey(fetcher: ApiFetcher, id: number): Promise<void> {
const put = fetcher.path(API_KEYS_ROUTES.REVOKE).method('put').create();
await put({ id });
}
shared/sdk-ts/src/authentication.ts
+18
View File
@@ -0,0 +1,18 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const AUTH_ROUTES = {
ACCOUNT: '/api/auth/account',
RESEND_SIGNUP: '/api/auth/signup/verify/resend',
} as const satisfies Record<string, keyof paths>;
type GetAuthedAccount = paths[typeof AUTH_ROUTES.ACCOUNT]['get'];
type GetAuthedAccount200 = GetAuthedAccount['responses'][200];
export type AuthedAccount = GetAuthedAccount200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export async function fetchAuthedAccount(fetcher: ApiFetcher): Promise<AuthedAccount> {
const get = fetcher.path(AUTH_ROUTES.ACCOUNT).method('get').create();
const { data } = await get({});
return data;
}
shared/sdk-ts/src/bills.ts
+59
View File
@@ -0,0 +1,59 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const BILLS_ROUTES = {
LIST: '/api/bills',
BY_ID: '/api/bills/{id}',
PAYMENT_TRANSACTIONS: '/api/bills/{id}/payment-transactions',
OPEN: '/api/bills/{id}/open',
DUE: '/api/bills/due',
VALIDATE_BULK_DELETE: '/api/bills/validate-bulk-delete',
BULK_DELETE: '/api/bills/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetBills = paths[typeof BILLS_ROUTES.LIST]['get'];
type GetBill = paths[typeof BILLS_ROUTES.BY_ID]['get'];
type CreateBill = paths[typeof BILLS_ROUTES.LIST]['post'];
type EditBill = paths[typeof BILLS_ROUTES.BY_ID]['put'];
type DeleteBill = paths[typeof BILLS_ROUTES.BY_ID]['delete'];
export type BillsListResponse = GetBills['responses'][200]['content']['application/json'];
export type Bill = GetBill['responses'][200]['content']['application/json'];
export type CreateBillBody = CreateBill['requestBody']['content']['application/json'];
export type EditBillBody = EditBill['requestBody']['content']['application/json'];
export async function fetchBills(fetcher: ApiFetcher): Promise<BillsListResponse> {
const get = fetcher.path(BILLS_ROUTES.LIST).method('get').create();
// Schema incorrectly marks path.id on list endpoint; route has no {id}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const { data } = await (get as (params?: any) => Promise<{ data: BillsListResponse }>)({});
return data;
}
export async function fetchBill(fetcher: ApiFetcher, id: number): Promise<Bill> {
const get = fetcher.path(BILLS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createBill(
fetcher: ApiFetcher,
values: CreateBillBody
): Promise<void> {
const post = fetcher.path(BILLS_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editBill(
fetcher: ApiFetcher,
id: number,
values: EditBillBody
): Promise<void> {
const put = fetcher.path(BILLS_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteBill(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(BILLS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
shared/sdk-ts/src/branches.ts
+64
View File
@@ -0,0 +1,64 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const BRANCHES_ROUTES = {
LIST: '/api/branches',
BY_ID: '/api/branches/{id}',
ACTIVATE: '/api/branches/activate',
MARK_AS_PRIMARY: '/api/branches/{id}/mark-as-primary',
} as const satisfies Record<string, keyof paths>;
type GetBranches = paths[typeof BRANCHES_ROUTES.LIST]['get'];
type GetBranch = paths[typeof BRANCHES_ROUTES.BY_ID]['get'];
type CreateBranch = paths[typeof BRANCHES_ROUTES.LIST]['post'];
type EditBranch = paths[typeof BRANCHES_ROUTES.BY_ID]['put'];
type DeleteBranch = paths[typeof BRANCHES_ROUTES.BY_ID]['delete'];
export type BranchesListResponse = GetBranches['responses'][200]['content']['application/json'];
export type Branch = GetBranch['responses'][200]['content']['application/json'];
export type CreateBranchBody = CreateBranch['requestBody']['content']['application/json'];
export type EditBranchBody = EditBranch['requestBody']['content']['application/json'];
export async function fetchBranches(fetcher: ApiFetcher): Promise<BranchesListResponse> {
const get = fetcher.path(BRANCHES_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchBranch(fetcher: ApiFetcher, id: string): Promise<Branch> {
const get = fetcher.path(BRANCHES_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createBranch(
fetcher: ApiFetcher,
values: CreateBranchBody
): Promise<void> {
const post = fetcher.path(BRANCHES_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editBranch(
fetcher: ApiFetcher,
id: string,
values: EditBranchBody
): Promise<void> {
const put = fetcher.path(BRANCHES_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteBranch(fetcher: ApiFetcher, id: string): Promise<void> {
const del = fetcher.path(BRANCHES_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function activateBranches(fetcher: ApiFetcher): Promise<void> {
const post = fetcher.path(BRANCHES_ROUTES.ACTIVATE).method('post').create();
await post({});
}
export async function markBranchAsPrimary(fetcher: ApiFetcher, id: string): Promise<void> {
const put = fetcher.path(BRANCHES_ROUTES.MARK_AS_PRIMARY).method('put').create();
await put({ id });
}
shared/sdk-ts/src/cashflow-accounts.ts
+26
View File
@@ -0,0 +1,26 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const BANKING_ACCOUNTS_ROUTES = {
LIST: '/api/banking/accounts',
SUMMARY: '/api/banking/accounts/{bankAccountId}/summary',
} as const satisfies Record<string, keyof paths>;
type GetBankingAccounts = paths[typeof BANKING_ACCOUNTS_ROUTES.LIST]['get'];
type GetBankingAccounts200 = GetBankingAccounts['responses'][200];
export type BankingAccountsListResponse = GetBankingAccounts200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export async function fetchBankingAccounts(fetcher: ApiFetcher): Promise<BankingAccountsListResponse> {
const get = fetcher.path(BANKING_ACCOUNTS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchBankingAccountSummary(
fetcher: ApiFetcher,
bankAccountId: number
): Promise<void> {
const get = fetcher.path(BANKING_ACCOUNTS_ROUTES.SUMMARY).method('get').create();
await get({ bankAccountId });
}
shared/sdk-ts/src/contacts.ts
+29
View File
@@ -0,0 +1,29 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const CONTACTS_ROUTES = {
AUTO_COMPLETE: '/api/contacts/auto-complete',
ACTIVATE: '/api/contacts/{id}/activate',
INACTIVATE: '/api/contacts/{id}/inactivate',
} as const satisfies Record<string, keyof paths>;
type AutoComplete = paths[typeof CONTACTS_ROUTES.AUTO_COMPLETE]['get'];
type AutoComplete200 = AutoComplete['responses'][200];
export type ContactsAutoCompleteResponse = AutoComplete200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export async function fetchContactsAutoComplete(fetcher: ApiFetcher): Promise<ContactsAutoCompleteResponse> {
const get = fetcher.path(CONTACTS_ROUTES.AUTO_COMPLETE).method('get').create();
const { data } = await get({});
return data;
}
export async function activateContact(fetcher: ApiFetcher, id: number): Promise<void> {
const patch = fetcher.path(CONTACTS_ROUTES.ACTIVATE).method('patch').create();
await patch({ id });
}
export async function inactivateContact(fetcher: ApiFetcher, id: number): Promise<void> {
const patch = fetcher.path(CONTACTS_ROUTES.INACTIVATE).method('patch').create();
await patch({ id });
}
shared/sdk-ts/src/credit-notes.ts
+162
View File
@@ -0,0 +1,162 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const CREDIT_NOTES_ROUTES = {
LIST: '/api/credit-notes',
BY_ID: '/api/credit-notes/{id}',
STATE: '/api/credit-notes/state',
OPEN: '/api/credit-notes/{id}/open',
VALIDATE_BULK_DELETE: '/api/credit-notes/validate-bulk-delete',
BULK_DELETE: '/api/credit-notes/bulk-delete',
REFUNDS: '/api/credit-notes/{creditNoteId}/refunds',
REFUND_BY_ID: '/api/credit-notes/refunds/{refundCreditId}',
APPLIED_INVOICES: '/api/credit-notes/{creditNoteId}/applied-invoices',
APPLY_INVOICES: '/api/credit-notes/{creditNoteId}/apply-invoices',
APPLIED_INVOICE_BY_ID: '/api/credit-notes/applied-invoices/{applyCreditToInvoicesId}',
} as const satisfies Record<string, keyof paths>;
type GetCreditNotes = paths[typeof CREDIT_NOTES_ROUTES.LIST]['get'];
type GetCreditNote = paths[typeof CREDIT_NOTES_ROUTES.BY_ID]['get'];
type GetCreditNoteState = paths[typeof CREDIT_NOTES_ROUTES.STATE]['get'];
type CreateCreditNote = paths[typeof CREDIT_NOTES_ROUTES.LIST]['post'];
type EditCreditNote = paths[typeof CREDIT_NOTES_ROUTES.BY_ID]['put'];
type DeleteCreditNote = paths[typeof CREDIT_NOTES_ROUTES.BY_ID]['delete'];
type OpenCreditNote = paths[typeof CREDIT_NOTES_ROUTES.OPEN]['put'];
type ValidateBulkDeleteCreditNotes = paths[typeof CREDIT_NOTES_ROUTES.VALIDATE_BULK_DELETE]['post'];
type BulkDeleteCreditNotes = paths[typeof CREDIT_NOTES_ROUTES.BULK_DELETE]['post'];
type GetCreditNoteRefunds = paths[typeof CREDIT_NOTES_ROUTES.REFUNDS]['get'];
type CreateRefundCreditNote = paths[typeof CREDIT_NOTES_ROUTES.REFUNDS]['post'];
type DeleteRefundCreditNote = paths[typeof CREDIT_NOTES_ROUTES.REFUND_BY_ID]['delete'];
type GetAppliedInvoices = paths[typeof CREDIT_NOTES_ROUTES.APPLIED_INVOICES]['get'];
type GetApplyInvoices = paths[typeof CREDIT_NOTES_ROUTES.APPLY_INVOICES]['get'];
type ApplyCreditNoteToInvoices = paths[typeof CREDIT_NOTES_ROUTES.APPLY_INVOICES]['post'];
type DeleteApplyCreditNoteToInvoices = paths[typeof CREDIT_NOTES_ROUTES.APPLIED_INVOICE_BY_ID]['delete'];
export type CreditNotesListResponse = GetCreditNotes['responses'][200]['content']['application/json'];
export type CreditNote = GetCreditNote['responses'][200]['content']['application/json'];
export type CreateCreditNoteBody = CreateCreditNote['requestBody']['content']['application/json'];
export type EditCreditNoteBody = EditCreditNote['requestBody']['content']['application/json'];
export type ValidateBulkDeleteCreditNotesBody = ValidateBulkDeleteCreditNotes['requestBody']['content']['application/json'];
export type ValidateBulkDeleteCreditNotesResponse = ValidateBulkDeleteCreditNotes['responses'][200]['content']['application/json'];
export type BulkDeleteCreditNotesBody = BulkDeleteCreditNotes['requestBody']['content']['application/json'];
export type CreateRefundCreditNoteBody = CreateRefundCreditNote['requestBody']['content']['application/json'];
export type ApplyCreditNoteToInvoicesBody = ApplyCreditNoteToInvoices['requestBody']['content']['application/json'];
export async function fetchCreditNotes(fetcher: ApiFetcher): Promise<CreditNotesListResponse> {
const getCreditNotes = fetcher.path(CREDIT_NOTES_ROUTES.LIST).method('get').create();
const { data } = await getCreditNotes({});
return data;
}
export async function fetchCreditNote(fetcher: ApiFetcher, id: number): Promise<CreditNote> {
const getCreditNote = fetcher.path(CREDIT_NOTES_ROUTES.BY_ID).method('get').create();
const { data } = await getCreditNote({ id });
return data;
}
export async function fetchCreditNoteState(fetcher: ApiFetcher): Promise<void> {
const getState = fetcher.path(CREDIT_NOTES_ROUTES.STATE).method('get').create();
await getState({});
}
export async function createCreditNote(
fetcher: ApiFetcher,
values: CreateCreditNoteBody
): Promise<void> {
const create = fetcher.path(CREDIT_NOTES_ROUTES.LIST).method('post').create();
await create(values);
}
export async function editCreditNote(
fetcher: ApiFetcher,
id: number,
values: EditCreditNoteBody
): Promise<void> {
const put = fetcher.path(CREDIT_NOTES_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteCreditNote(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(CREDIT_NOTES_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function openCreditNote(fetcher: ApiFetcher, id: number): Promise<void> {
const open = fetcher.path(CREDIT_NOTES_ROUTES.OPEN).method('put').create();
await open({ id });
}
export async function validateBulkDeleteCreditNotes(
fetcher: ApiFetcher,
body: ValidateBulkDeleteCreditNotesBody
): Promise<ValidateBulkDeleteCreditNotesResponse> {
const validate = fetcher.path(CREDIT_NOTES_ROUTES.VALIDATE_BULK_DELETE).method('post').create();
const { data } = await validate(body);
return data;
}
export async function bulkDeleteCreditNotes(
fetcher: ApiFetcher,
body: BulkDeleteCreditNotesBody
): Promise<void> {
const bulkDelete = fetcher.path(CREDIT_NOTES_ROUTES.BULK_DELETE).method('post').create();
await bulkDelete(body);
}
export async function fetchCreditNoteRefunds(
fetcher: ApiFetcher,
creditNoteId: number
): Promise<void> {
const getRefunds = fetcher.path(CREDIT_NOTES_ROUTES.REFUNDS).method('get').create();
await getRefunds({ creditNoteId });
}
export async function createRefundCreditNote(
fetcher: ApiFetcher,
creditNoteId: number,
values: CreateRefundCreditNoteBody
): Promise<void> {
const create = fetcher.path(CREDIT_NOTES_ROUTES.REFUNDS).method('post').create();
await create({ creditNoteId, ...values });
}
export async function deleteRefundCreditNote(
fetcher: ApiFetcher,
refundCreditId: number
): Promise<void> {
const del = fetcher.path(CREDIT_NOTES_ROUTES.REFUND_BY_ID).method('delete').create();
await del({ refundCreditId });
}
export async function fetchAppliedInvoices(
fetcher: ApiFetcher,
creditNoteId: number
): Promise<void> {
const getApplied = fetcher.path(CREDIT_NOTES_ROUTES.APPLIED_INVOICES).method('get').create();
await getApplied({ creditNoteId });
}
export async function fetchCreditNoteAssociatedInvoicesToApply(
fetcher: ApiFetcher,
creditNoteId: number
): Promise<void> {
const get = fetcher.path(CREDIT_NOTES_ROUTES.APPLY_INVOICES).method('get').create();
await get({ creditNoteId });
}
export async function applyCreditNoteToInvoices(
fetcher: ApiFetcher,
creditNoteId: number,
values: ApplyCreditNoteToInvoicesBody
): Promise<void> {
const apply = fetcher.path(CREDIT_NOTES_ROUTES.APPLY_INVOICES).method('post').create();
await apply({ creditNoteId, ...values });
}
export async function deleteApplyCreditNoteToInvoices(
fetcher: ApiFetcher,
applyCreditToInvoicesId: number
): Promise<void> {
const del = fetcher.path(CREDIT_NOTES_ROUTES.APPLIED_INVOICE_BY_ID).method('delete').create();
await del({ applyCreditToInvoicesId });
}
shared/sdk-ts/src/currencies.ts
+34
View File
@@ -0,0 +1,34 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const CURRENCIES_ROUTES = {
LIST: '/api/currencies',
BY_ID: '/api/currencies/{id}',
BY_CODE: '/api/currencies/{code}',
BY_CURRENCY_CODE: '/api/currencies/{currencyCode}',
} as const satisfies Record<string, keyof paths>;
type GetCurrencies = paths[typeof CURRENCIES_ROUTES.LIST]['get'];
type GetCurrencyByCode = paths[typeof CURRENCIES_ROUTES.BY_CURRENCY_CODE]['get'];
type GetCurrencies200 = GetCurrencies['responses'][200];
type GetCurrencyByCode200 = GetCurrencyByCode['responses'][200];
export type CurrenciesListResponse = GetCurrencies200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type Currency = GetCurrencyByCode200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export async function fetchCurrencies(fetcher: ApiFetcher): Promise<CurrenciesListResponse> {
const get = fetcher.path(CURRENCIES_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchCurrencyByCode(fetcher: ApiFetcher, currencyCode: string): Promise<Currency> {
const get = fetcher.path(CURRENCIES_ROUTES.BY_CURRENCY_CODE).method('get').create();
const { data } = await get({ currencyCode });
return data;
}
/** @deprecated Use fetchCurrencyByCode - schema has no get by id */
export async function fetchCurrency(fetcher: ApiFetcher, id: number): Promise<Currency> {
return fetchCurrencyByCode(fetcher, String(id));
}
shared/sdk-ts/src/customers.ts
+76
View File
@@ -0,0 +1,76 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const CUSTOMERS_ROUTES = {
LIST: '/api/customers',
BY_ID: '/api/customers/{id}',
OPENING_BALANCE: '/api/customers/{id}/opening-balance',
VALIDATE_BULK_DELETE: '/api/customers/validate-bulk-delete',
BULK_DELETE: '/api/customers/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetCustomers = paths[typeof CUSTOMERS_ROUTES.LIST]['get'];
type GetCustomer = paths[typeof CUSTOMERS_ROUTES.BY_ID]['get'];
type CreateCustomer = paths[typeof CUSTOMERS_ROUTES.LIST]['post'];
type EditCustomer = paths[typeof CUSTOMERS_ROUTES.BY_ID]['put'];
type DeleteCustomer = paths[typeof CUSTOMERS_ROUTES.BY_ID]['delete'];
type ValidateBulkDelete = paths[typeof CUSTOMERS_ROUTES.VALIDATE_BULK_DELETE]['post'];
type BulkDelete = paths[typeof CUSTOMERS_ROUTES.BULK_DELETE]['post'];
export type CustomersListResponse = GetCustomers['responses'][200]['content']['application/json'];
export type Customer = GetCustomer['responses'][200]['content']['application/json'];
export type CreateCustomerBody = CreateCustomer['requestBody']['content']['application/json'];
export type EditCustomerBody = EditCustomer['requestBody']['content']['application/json'];
export type ValidateBulkDeleteCustomersResponse = ValidateBulkDelete['responses'][200]['content']['application/json'];
export type BulkDeleteCustomersBody = BulkDelete['requestBody']['content']['application/json'];
export async function fetchCustomers(fetcher: ApiFetcher): Promise<CustomersListResponse> {
const get = fetcher.path(CUSTOMERS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchCustomer(fetcher: ApiFetcher, id: number): Promise<Customer> {
const get = fetcher.path(CUSTOMERS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createCustomer(
fetcher: ApiFetcher,
values: CreateCustomerBody
): Promise<void> {
const post = fetcher.path(CUSTOMERS_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editCustomer(
fetcher: ApiFetcher,
id: number,
values: EditCustomerBody
): Promise<void> {
const put = fetcher.path(CUSTOMERS_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteCustomer(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(CUSTOMERS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function validateBulkDeleteCustomers(
fetcher: ApiFetcher,
body: BulkDeleteCustomersBody
): Promise<ValidateBulkDeleteCustomersResponse> {
const validate = fetcher.path(CUSTOMERS_ROUTES.VALIDATE_BULK_DELETE).method('post').create();
const { data } = await validate(body);
return data;
}
export async function bulkDeleteCustomers(
fetcher: ApiFetcher,
body: BulkDeleteCustomersBody
): Promise<void> {
const post = fetcher.path(CUSTOMERS_ROUTES.BULK_DELETE).method('post').create();
await post(body);
}
shared/sdk-ts/src/expenses.ts
+62
View File
@@ -0,0 +1,62 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const EXPENSES_ROUTES = {
LIST: '/api/expenses',
BY_ID: '/api/expenses/{id}',
PUBLISH: '/api/expenses/{id}/publish',
VALIDATE_BULK_DELETE: '/api/expenses/validate-bulk-delete',
BULK_DELETE: '/api/expenses/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetExpenses = paths[typeof EXPENSES_ROUTES.LIST]['get'];
type GetExpense = paths[typeof EXPENSES_ROUTES.BY_ID]['get'];
type CreateExpense = paths[typeof EXPENSES_ROUTES.LIST]['post'];
type EditExpense = paths[typeof EXPENSES_ROUTES.BY_ID]['put'];
type DeleteExpense = paths[typeof EXPENSES_ROUTES.BY_ID]['delete'];
type GetExpenses200 = GetExpenses['responses'][200];
type GetExpense200 = GetExpense['responses'][200];
export type ExpensesListResponse = GetExpenses200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type Expense = GetExpense200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateExpenseBody = CreateExpense['requestBody']['content']['application/json'];
export type EditExpenseBody = EditExpense['requestBody']['content']['application/json'];
export async function fetchExpenses(fetcher: ApiFetcher): Promise<ExpensesListResponse> {
const get = fetcher.path(EXPENSES_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchExpense(fetcher: ApiFetcher, id: number): Promise<Expense> {
const get = fetcher.path(EXPENSES_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createExpense(
fetcher: ApiFetcher,
values: CreateExpenseBody
): Promise<void> {
const post = fetcher.path(EXPENSES_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editExpense(
fetcher: ApiFetcher,
id: number,
values: EditExpenseBody
): Promise<void> {
const put = fetcher.path(EXPENSES_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteExpense(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(EXPENSES_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function publishExpense(fetcher: ApiFetcher, id: number): Promise<void> {
const post = fetcher.path(EXPENSES_ROUTES.PUBLISH).method('post').create();
await post({ id });
}
shared/sdk-ts/src/fetch-utils.ts
+11
View File
@@ -0,0 +1,11 @@
import { Fetcher } from 'openapi-typescript-fetch';
import type { paths } from './schema';
export type ApiFetcher = ReturnType<typeof Fetcher.for<paths>>;
/**
* Strips leading slash from a path segment to avoid double slashes when joining with a base (e.g. `/api/` + path).
*/
export function normalizeApiPath(path: string): string {
return (path || '').replace(/^\//, '');
}
shared/sdk-ts/src/generic-resource.ts
+20
View File
@@ -0,0 +1,20 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const GENERIC_RESOURCE_ROUTES = {
META: '/api/resources/{resourceModel}/meta',
} as const satisfies Record<string, keyof paths>;
type GetResourceMeta = paths[typeof GENERIC_RESOURCE_ROUTES.META]['get'];
type GetResourceMeta200 = GetResourceMeta['responses'][200];
export type ResourceMetaResponse = GetResourceMeta200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export async function fetchResourceMeta(
fetcher: ApiFetcher,
resourceModel: string
): Promise<ResourceMetaResponse> {
const get = fetcher.path(GENERIC_RESOURCE_ROUTES.META).method('get').create();
const { data } = await get({ resourceModel });
return data;
}
shared/sdk-ts/src/index.ts
+434
View File
@@ -0,0 +1,434 @@
/**
* Re-export OpenAPI-generated types for use by server and webapp.
* Run `pnpm run generate:sdk-types` from repo root to regenerate schema from the server OpenAPI spec.
*/
export type { paths, components, operations } from './schema';
export { normalizeApiPath, ApiFetcher } from './fetch-utils';
export {
ACCOUNTS_ROUTES,
fetchAccounts,
fetchAccount,
fetchAccountTypes,
fetchAccountTransactions,
createAccount,
editAccount,
deleteAccount,
activateAccount,
inactivateAccount,
bulkDeleteAccounts,
validateBulkDeleteAccounts,
} from './accounts';
export type {
AccountsList,
Account,
AccountTypesList,
AccountTransactionsList,
CreateAccountBody,
EditAccountBody,
BulkDeleteBody,
ValidateBulkDeleteResponse,
GetAccountsQuery,
} from './accounts';
export {
CREDIT_NOTES_ROUTES,
fetchCreditNotes,
fetchCreditNote,
fetchCreditNoteState,
createCreditNote,
editCreditNote,
deleteCreditNote,
openCreditNote,
validateBulkDeleteCreditNotes,
bulkDeleteCreditNotes,
fetchCreditNoteRefunds,
createRefundCreditNote,
deleteRefundCreditNote,
fetchAppliedInvoices,
fetchCreditNoteAssociatedInvoicesToApply,
applyCreditNoteToInvoices,
deleteApplyCreditNoteToInvoices,
} from './credit-notes';
export type {
CreditNotesListResponse,
CreditNote,
CreateCreditNoteBody,
EditCreditNoteBody,
ValidateBulkDeleteCreditNotesBody,
ValidateBulkDeleteCreditNotesResponse,
BulkDeleteCreditNotesBody,
CreateRefundCreditNoteBody,
ApplyCreditNoteToInvoicesBody,
} from './credit-notes';
export {
API_KEYS_ROUTES,
fetchApiKeys,
generateApiKey,
revokeApiKey,
} from './api-keys';
export type { ApiKeysList, GenerateApiKeyBody } from './api-keys';
export {
SALE_INVOICES_ROUTES,
fetchSaleInvoices,
fetchSaleInvoice,
createSaleInvoice,
editSaleInvoice,
deleteSaleInvoice,
} from './sale-invoices';
export type {
SaleInvoicesListResponse,
SaleInvoice,
CreateSaleInvoiceBody,
EditSaleInvoiceBody,
} from './sale-invoices';
export {
CUSTOMERS_ROUTES,
fetchCustomers,
fetchCustomer,
createCustomer,
editCustomer,
deleteCustomer,
validateBulkDeleteCustomers,
bulkDeleteCustomers,
} from './customers';
export type {
CustomersListResponse,
Customer,
CreateCustomerBody,
EditCustomerBody,
ValidateBulkDeleteCustomersResponse,
BulkDeleteCustomersBody,
} from './customers';
export {
VENDORS_ROUTES,
fetchVendors,
fetchVendor,
createVendor,
editVendor,
deleteVendor,
validateBulkDeleteVendors,
bulkDeleteVendors,
} from './vendors';
export type {
VendorsListResponse,
Vendor,
CreateVendorBody,
EditVendorBody,
ValidateBulkDeleteVendorsResponse,
BulkDeleteVendorsBody,
} from './vendors';
export {
BILLS_ROUTES,
fetchBills,
fetchBill,
createBill,
editBill,
deleteBill,
} from './bills';
export type {
BillsListResponse,
Bill,
CreateBillBody,
EditBillBody,
} from './bills';
export {
ITEMS_ROUTES,
fetchItems,
fetchItem,
createItem,
editItem,
deleteItem,
inactivateItem,
activateItem,
validateBulkDeleteItems,
bulkDeleteItems,
} from './items';
export type {
ItemsListResponse,
Item,
CreateItemBody,
EditItemBody,
BulkDeleteItemsBody,
ValidateBulkDeleteItemsResponse,
} from './items';
export {
BRANCHES_ROUTES,
fetchBranches,
fetchBranch,
createBranch,
editBranch,
deleteBranch,
activateBranches,
markBranchAsPrimary,
} from './branches';
export type {
BranchesListResponse,
Branch,
CreateBranchBody,
EditBranchBody,
} from './branches';
export {
WAREHOUSES_ROUTES,
fetchWarehouses,
fetchWarehouse,
createWarehouse,
editWarehouse,
deleteWarehouse,
activateWarehouses,
markWarehousePrimary,
} from './warehouses';
export type {
WarehousesListResponse,
Warehouse,
CreateWarehouseBody,
EditWarehouseBody,
} from './warehouses';
export {
EXPENSES_ROUTES,
fetchExpenses,
fetchExpense,
createExpense,
editExpense,
deleteExpense,
publishExpense,
} from './expenses';
export type {
ExpensesListResponse,
Expense,
CreateExpenseBody,
EditExpenseBody,
} from './expenses';
export {
MANUAL_JOURNALS_ROUTES,
fetchManualJournals,
fetchManualJournal,
createManualJournal,
editManualJournal,
deleteManualJournal,
publishManualJournal,
} from './manual-journals';
export type {
ManualJournalsListResponse,
ManualJournal,
CreateManualJournalBody,
EditManualJournalBody,
} from './manual-journals';
export {
ROLES_ROUTES,
fetchRoles,
fetchRole,
createRole,
editRole,
deleteRole,
fetchRolePermissionsSchema,
} from './roles';
export type {
RolesListResponse,
Role,
CreateRoleBody,
EditRoleBody,
RolePermissionsSchema,
} from './roles';
export {
USERS_ROUTES,
fetchUsers,
fetchUser,
editUser,
deleteUser,
activateUser,
inactivateUser,
} from './users';
export type {
UsersListResponse,
User,
EditUserBody,
GetUsersQuery,
} from './users';
export {
SETTINGS_ROUTES,
fetchSettings,
saveSettings,
} from './settings';
export type { SettingsResponse, SaveSettingsBody } from './settings';
export {
ORGANIZATION_ROUTES,
fetchOrganizationCurrent,
fetchOrganization,
updateOrganization,
} from './organization';
export type {
OrganizationCurrent,
Organization,
UpdateOrganizationBody,
} from './organization';
export {
SUBSCRIPTION_ROUTES,
fetchSubscriptions,
cancelSubscription,
resumeSubscription,
} from './subscription';
export type { SubscriptionsListResponse } from './subscription';
export {
CURRENCIES_ROUTES,
fetchCurrencies,
fetchCurrency,
fetchCurrencyByCode,
} from './currencies';
export type { CurrenciesListResponse, Currency } from './currencies';
export {
INVITE_ROUTES,
inviteUser,
resendInvite,
} from './invite';
export type { InviteUserBody } from './invite';
export {
AUTH_ROUTES,
fetchAuthedAccount,
} from './authentication';
export type { AuthedAccount } from './authentication';
export {
CONTACTS_ROUTES,
fetchContactsAutoComplete,
activateContact,
inactivateContact,
} from './contacts';
export type { ContactsAutoCompleteResponse } from './contacts';
export {
ITEMS_CATEGORIES_ROUTES,
fetchItemCategories,
fetchItemCategory,
createItemCategory,
editItemCategory,
deleteItemCategory,
} from './items-categories';
export type {
ItemCategoriesListResponse,
ItemCategory,
CreateItemCategoryBody,
EditItemCategoryBody,
} from './items-categories';
export {
VIEWS_ROUTES,
fetchResourceView,
} from './views';
export type { ResourceViewResponse } from './views';
export {
TRANSACTIONS_LOCKING_ROUTES,
fetchTransactionsLocking,
fetchTransactionsLockingByModule,
} from './transactions-locking';
export {
VENDOR_CREDITS_ROUTES,
fetchVendorCredits,
fetchVendorCredit,
createVendorCredit,
editVendorCredit,
deleteVendorCredit,
openVendorCredit,
} from './vendor-credits';
export type {
VendorCreditsListResponse,
VendorCredit,
CreateVendorCreditBody,
EditVendorCreditBody,
} from './vendor-credits';
export {
SALE_ESTIMATES_ROUTES,
fetchSaleEstimates,
fetchSaleEstimate,
createSaleEstimate,
editSaleEstimate,
deleteSaleEstimate,
} from './sale-estimates';
export type {
SaleEstimatesListResponse,
SaleEstimate,
CreateSaleEstimateBody,
EditSaleEstimateBody,
} from './sale-estimates';
export {
SALE_RECEIPTS_ROUTES,
fetchSaleReceipts,
fetchSaleReceipt,
createSaleReceipt,
editSaleReceipt,
deleteSaleReceipt,
} from './sale-receipts';
export type {
SaleReceiptsListResponse,
SaleReceipt,
CreateSaleReceiptBody,
EditSaleReceiptBody,
} from './sale-receipts';
export {
PAYMENTS_RECEIVED_ROUTES,
fetchPaymentsReceived,
fetchPaymentReceived,
createPaymentReceived,
editPaymentReceived,
deletePaymentReceived,
} from './payment-receives';
export type {
PaymentsReceivedListResponse,
PaymentReceived,
CreatePaymentReceivedBody,
EditPaymentReceivedBody,
} from './payment-receives';
export {
BILL_PAYMENTS_ROUTES,
fetchBillPayments,
fetchBillPayment,
createBillPayment,
editBillPayment,
deleteBillPayment,
} from './payment-mades';
export type {
BillPaymentsListResponse,
BillPayment,
CreateBillPaymentBody,
EditBillPaymentBody,
} from './payment-mades';
export {
INVENTORY_ADJUSTMENTS_ROUTES,
fetchInventoryAdjustments,
fetchInventoryAdjustment,
createQuickInventoryAdjustment,
deleteInventoryAdjustment,
publishInventoryAdjustment,
} from './inventory-adjustments';
export type {
InventoryAdjustmentsListResponse,
InventoryAdjustment,
CreateQuickInventoryAdjustmentBody,
} from './inventory-adjustments';
export {
WAREHOUSE_TRANSFERS_ROUTES,
fetchWarehouseTransfers,
fetchWarehouseTransfer,
createWarehouseTransfer,
editWarehouseTransfer,
deleteWarehouseTransfer,
initiateWarehouseTransfer,
transferredWarehouseTransfer,
} from './warehouse-transfers';
export type {
WarehouseTransfersListResponse,
WarehouseTransfer,
CreateWarehouseTransferBody,
EditWarehouseTransferBody,
} from './warehouse-transfers';
export {
LANDED_COST_ROUTES,
fetchLandedCostTransactions,
} from './landed-cost';
export type { LandedCostTransactionsResponse } from './landed-cost';
export {
GENERIC_RESOURCE_ROUTES,
fetchResourceMeta,
} from './generic-resource';
export type { ResourceMetaResponse } from './generic-resource';
export {
BANKING_ACCOUNTS_ROUTES,
fetchBankingAccounts,
fetchBankingAccountSummary,
} from './cashflow-accounts';
export type { BankingAccountsListResponse } from './cashflow-accounts';
shared/sdk-ts/src/inventory-adjustments.ts
+50
View File
@@ -0,0 +1,50 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const INVENTORY_ADJUSTMENTS_ROUTES = {
LIST: '/api/inventory-adjustments',
BY_ID: '/api/inventory-adjustments/{id}',
QUICK: '/api/inventory-adjustments/quick',
PUBLISH: '/api/inventory-adjustments/{id}/publish',
} as const satisfies Record<string, keyof paths>;
type GetInventoryAdjustments = paths[typeof INVENTORY_ADJUSTMENTS_ROUTES.LIST]['get'];
type GetInventoryAdjustment = paths[typeof INVENTORY_ADJUSTMENTS_ROUTES.BY_ID]['get'];
type CreateQuick = paths[typeof INVENTORY_ADJUSTMENTS_ROUTES.QUICK]['post'];
type DeleteInventoryAdjustment = paths[typeof INVENTORY_ADJUSTMENTS_ROUTES.BY_ID]['delete'];
type GetInventoryAdjustments200 = GetInventoryAdjustments['responses'][200];
type GetInventoryAdjustment200 = GetInventoryAdjustment['responses'][200];
export type InventoryAdjustmentsListResponse = GetInventoryAdjustments200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type InventoryAdjustment = GetInventoryAdjustment200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateQuickInventoryAdjustmentBody = CreateQuick['requestBody']['content']['application/json'];
export async function fetchInventoryAdjustments(fetcher: ApiFetcher): Promise<InventoryAdjustmentsListResponse> {
const get = fetcher.path(INVENTORY_ADJUSTMENTS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchInventoryAdjustment(fetcher: ApiFetcher, id: number): Promise<InventoryAdjustment> {
const get = fetcher.path(INVENTORY_ADJUSTMENTS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createQuickInventoryAdjustment(
fetcher: ApiFetcher,
values: CreateQuickInventoryAdjustmentBody
): Promise<void> {
const post = fetcher.path(INVENTORY_ADJUSTMENTS_ROUTES.QUICK).method('post').create();
await post(values);
}
export async function deleteInventoryAdjustment(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(INVENTORY_ADJUSTMENTS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function publishInventoryAdjustment(fetcher: ApiFetcher, id: number): Promise<void> {
const put = fetcher.path(INVENTORY_ADJUSTMENTS_ROUTES.PUBLISH).method('put').create();
await put({ id });
}
shared/sdk-ts/src/invite.ts
+27
View File
@@ -0,0 +1,27 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const INVITE_ROUTES = {
INVITE: '/api/invite',
RESEND: '/api/invite/users/{id}/resend',
ACCEPT: '/api/invite/accept/{token}',
CHECK: '/api/invite/check/{token}',
} as const satisfies Record<string, keyof paths>;
type InviteUser = paths[typeof INVITE_ROUTES.INVITE]['patch'];
type ResendInvite = paths[typeof INVITE_ROUTES.RESEND]['post'];
export type InviteUserBody = InviteUser['requestBody']['content']['application/json'];
export async function inviteUser(
fetcher: ApiFetcher,
values: InviteUserBody
): Promise<void> {
const patch = fetcher.path(INVITE_ROUTES.INVITE).method('patch').create();
await patch(values);
}
export async function resendInvite(fetcher: ApiFetcher, id: number): Promise<void> {
const post = fetcher.path(INVITE_ROUTES.RESEND).method('post').create();
await post({ id });
}
shared/sdk-ts/src/items-categories.ts
+54
View File
@@ -0,0 +1,54 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const ITEMS_CATEGORIES_ROUTES = {
LIST: '/api/item-categories',
BY_ID: '/api/item-categories/{id}',
} as const satisfies Record<string, keyof paths>;
type GetItemCategories = paths[typeof ITEMS_CATEGORIES_ROUTES.LIST]['get'];
type GetItemCategory = paths[typeof ITEMS_CATEGORIES_ROUTES.BY_ID]['get'];
type CreateItemCategory = paths[typeof ITEMS_CATEGORIES_ROUTES.LIST]['post'];
type EditItemCategory = paths[typeof ITEMS_CATEGORIES_ROUTES.BY_ID]['put'];
type DeleteItemCategory = paths[typeof ITEMS_CATEGORIES_ROUTES.BY_ID]['delete'];
type GetItemCategories200 = GetItemCategories['responses'][200];
type GetItemCategory200 = GetItemCategory['responses'][200];
export type ItemCategoriesListResponse = GetItemCategories200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type ItemCategory = GetItemCategory200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateItemCategoryBody = CreateItemCategory['requestBody']['content']['application/json'];
export type EditItemCategoryBody = EditItemCategory['requestBody']['content']['application/json'];
export async function fetchItemCategories(fetcher: ApiFetcher): Promise<ItemCategoriesListResponse> {
const get = fetcher.path(ITEMS_CATEGORIES_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchItemCategory(fetcher: ApiFetcher, id: number): Promise<ItemCategory> {
const get = fetcher.path(ITEMS_CATEGORIES_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createItemCategory(
fetcher: ApiFetcher,
values: CreateItemCategoryBody
): Promise<void> {
const post = fetcher.path(ITEMS_CATEGORIES_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editItemCategory(
fetcher: ApiFetcher,
id: number,
values: EditItemCategoryBody
): Promise<void> {
const put = fetcher.path(ITEMS_CATEGORIES_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteItemCategory(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(ITEMS_CATEGORIES_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
shared/sdk-ts/src/items.ts
+92
View File
@@ -0,0 +1,92 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const ITEMS_ROUTES = {
LIST: '/api/items',
BY_ID: '/api/items/{id}',
VALIDATE_BULK_DELETE: '/api/items/validate-bulk-delete',
BULK_DELETE: '/api/items/bulk-delete',
INACTIVATE: '/api/items/{id}/inactivate',
ACTIVATE: '/api/items/{id}/activate',
INVOICES: '/api/items/{id}/invoices',
BILLS: '/api/items/{id}/bills',
ESTIMATES: '/api/items/{id}/estimates',
RECEIPTS: '/api/items/{id}/receipts',
WAREHOUSES: '/api/items/{id}/warehouses',
} as const satisfies Record<string, keyof paths>;
type GetItems = paths[typeof ITEMS_ROUTES.LIST]['get'];
type GetItem = paths[typeof ITEMS_ROUTES.BY_ID]['get'];
type CreateItem = paths[typeof ITEMS_ROUTES.LIST]['post'];
type EditItem = paths[typeof ITEMS_ROUTES.BY_ID]['put'];
type DeleteItem = paths[typeof ITEMS_ROUTES.BY_ID]['delete'];
type BulkDelete = paths[typeof ITEMS_ROUTES.BULK_DELETE]['post'];
type ValidateBulkDelete = paths[typeof ITEMS_ROUTES.VALIDATE_BULK_DELETE]['post'];
export type ItemsListResponse = GetItems['responses'][200]['content']['application/json'];
export type Item = GetItem['responses'][200]['content']['application/json'];
export type CreateItemBody = CreateItem['requestBody']['content']['application/json'];
export type EditItemBody = EditItem['requestBody']['content']['application/json'];
export type BulkDeleteItemsBody = BulkDelete['requestBody']['content']['application/json'];
export type ValidateBulkDeleteItemsResponse = ValidateBulkDelete['responses'][200]['content']['application/json'];
export async function fetchItems(fetcher: ApiFetcher): Promise<ItemsListResponse> {
const get = fetcher.path(ITEMS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchItem(fetcher: ApiFetcher, id: number): Promise<Item> {
const get = fetcher.path(ITEMS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createItem(
fetcher: ApiFetcher,
values: CreateItemBody
): Promise<void> {
const post = fetcher.path(ITEMS_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editItem(
fetcher: ApiFetcher,
id: number,
values: EditItemBody
): Promise<void> {
const put = fetcher.path(ITEMS_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteItem(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(ITEMS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function inactivateItem(fetcher: ApiFetcher, id: number): Promise<void> {
const patch = fetcher.path(ITEMS_ROUTES.INACTIVATE).method('patch').create();
await patch({ id });
}
export async function activateItem(fetcher: ApiFetcher, id: number): Promise<void> {
const patch = fetcher.path(ITEMS_ROUTES.ACTIVATE).method('patch').create();
await patch({ id });
}
export async function validateBulkDeleteItems(
fetcher: ApiFetcher,
body: BulkDeleteItemsBody
): Promise<ValidateBulkDeleteItemsResponse> {
const validate = fetcher.path(ITEMS_ROUTES.VALIDATE_BULK_DELETE).method('post').create();
const { data } = await validate(body);
return data;
}
export async function bulkDeleteItems(
fetcher: ApiFetcher,
body: BulkDeleteItemsBody
): Promise<void> {
const post = fetcher.path(ITEMS_ROUTES.BULK_DELETE).method('post').create();
await post(body);
}
shared/sdk-ts/src/landed-cost.ts
+20
View File
@@ -0,0 +1,20 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const LANDED_COST_ROUTES = {
TRANSACTIONS: '/api/landed-cost/transactions',
ALLOCATE: '/api/landed-cost/bills/{billId}/allocate',
BY_ID: '/api/landed-cost/{allocatedLandedCostId}',
BILL_TRANSACTIONS: '/api/landed-cost/bills/{billId}/transactions',
} as const satisfies Record<string, keyof paths>;
type GetLandedCostTransactions = paths[typeof LANDED_COST_ROUTES.TRANSACTIONS]['get'];
type GetLandedCostTransactions200 = GetLandedCostTransactions['responses'][200];
export type LandedCostTransactionsResponse = GetLandedCostTransactions200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export async function fetchLandedCostTransactions(fetcher: ApiFetcher): Promise<LandedCostTransactionsResponse> {
const get = fetcher.path(LANDED_COST_ROUTES.TRANSACTIONS).method('get').create();
const { data } = await get({});
return data;
}
shared/sdk-ts/src/manual-journals.ts
+62
View File
@@ -0,0 +1,62 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const MANUAL_JOURNALS_ROUTES = {
LIST: '/api/manual-journals',
BY_ID: '/api/manual-journals/{id}',
PUBLISH: '/api/manual-journals/{id}/publish',
VALIDATE_BULK_DELETE: '/api/manual-journals/validate-bulk-delete',
BULK_DELETE: '/api/manual-journals/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetManualJournals = paths[typeof MANUAL_JOURNALS_ROUTES.LIST]['get'];
type GetManualJournal = paths[typeof MANUAL_JOURNALS_ROUTES.BY_ID]['get'];
type CreateManualJournal = paths[typeof MANUAL_JOURNALS_ROUTES.LIST]['post'];
type EditManualJournal = paths[typeof MANUAL_JOURNALS_ROUTES.BY_ID]['put'];
type DeleteManualJournal = paths[typeof MANUAL_JOURNALS_ROUTES.BY_ID]['delete'];
type GetManualJournals200 = GetManualJournals['responses'][200];
type GetManualJournal200 = GetManualJournal['responses'][200];
export type ManualJournalsListResponse = GetManualJournals200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type ManualJournal = GetManualJournal200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateManualJournalBody = CreateManualJournal['requestBody']['content']['application/json'];
export type EditManualJournalBody = EditManualJournal['requestBody']['content']['application/json'];
export async function fetchManualJournals(fetcher: ApiFetcher): Promise<ManualJournalsListResponse> {
const get = fetcher.path(MANUAL_JOURNALS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchManualJournal(fetcher: ApiFetcher, id: number): Promise<ManualJournal> {
const get = fetcher.path(MANUAL_JOURNALS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createManualJournal(
fetcher: ApiFetcher,
values: CreateManualJournalBody
): Promise<void> {
const post = fetcher.path(MANUAL_JOURNALS_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editManualJournal(
fetcher: ApiFetcher,
id: number,
values: EditManualJournalBody
): Promise<void> {
const put = fetcher.path(MANUAL_JOURNALS_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteManualJournal(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(MANUAL_JOURNALS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function publishManualJournal(fetcher: ApiFetcher, id: number): Promise<void> {
const patch = fetcher.path(MANUAL_JOURNALS_ROUTES.PUBLISH).method('patch').create();
await patch({ id });
}
shared/sdk-ts/src/organization.ts
+36
View File
@@ -0,0 +1,36 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const ORGANIZATION_ROUTES = {
CURRENT: '/api/organization/current',
BUILD: '/api/organization/build',
BUILD_JOB: '/api/organization/build/{buildJobId}',
BASE_CURRENCY_MUTATE: '/api/organization/base-currency-mutate',
UPDATE: '/api/organization',
} as const satisfies Record<string, keyof paths>;
type GetCurrent = paths[typeof ORGANIZATION_ROUTES.CURRENT]['get'];
type UpdateOrganization = paths[typeof ORGANIZATION_ROUTES.UPDATE]['put'];
type GetCurrent200 = GetCurrent['responses'][200];
export type OrganizationCurrent = GetCurrent200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type UpdateOrganizationBody = UpdateOrganization['requestBody']['content']['application/json'];
export async function fetchOrganizationCurrent(fetcher: ApiFetcher): Promise<OrganizationCurrent> {
const get = fetcher.path(ORGANIZATION_ROUTES.CURRENT).method('get').create();
const { data } = await get({});
return data;
}
export async function updateOrganization(
fetcher: ApiFetcher,
values: UpdateOrganizationBody
): Promise<void> {
const put = fetcher.path(ORGANIZATION_ROUTES.UPDATE).method('put').create();
await put(values);
}
export type Organization = OrganizationCurrent;
export async function fetchOrganization(fetcher: ApiFetcher): Promise<Organization> {
return fetchOrganizationCurrent(fetcher);
}
shared/sdk-ts/src/payment-mades.ts
+57
View File
@@ -0,0 +1,57 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const BILL_PAYMENTS_ROUTES = {
LIST: '/api/bill-payments',
BY_ID: '/api/bill-payments/{billPaymentId}',
NEW_PAGE_ENTRIES: '/api/bill-payments/new-page/entries',
BILLS: '/api/bill-payments/{billPaymentId}/bills',
EDIT_PAGE: '/api/bill-payments/{billPaymentId}/edit-page',
} as const satisfies Record<string, keyof paths>;
type GetBillPayments = paths[typeof BILL_PAYMENTS_ROUTES.LIST]['get'];
type GetBillPayment = paths[typeof BILL_PAYMENTS_ROUTES.BY_ID]['get'];
type CreateBillPayment = paths[typeof BILL_PAYMENTS_ROUTES.LIST]['post'];
type EditBillPayment = paths[typeof BILL_PAYMENTS_ROUTES.BY_ID]['put'];
type DeleteBillPayment = paths[typeof BILL_PAYMENTS_ROUTES.BY_ID]['delete'];
type GetBillPayments200 = GetBillPayments['responses'][200];
type GetBillPayment200 = GetBillPayment['responses'][200];
export type BillPaymentsListResponse = GetBillPayments200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type BillPayment = GetBillPayment200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateBillPaymentBody = CreateBillPayment['requestBody']['content']['application/json'];
export type EditBillPaymentBody = EditBillPayment['requestBody']['content']['application/json'];
export async function fetchBillPayments(fetcher: ApiFetcher): Promise<BillPaymentsListResponse> {
const get = fetcher.path(BILL_PAYMENTS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchBillPayment(fetcher: ApiFetcher, billPaymentId: number): Promise<BillPayment> {
const get = fetcher.path(BILL_PAYMENTS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ billPaymentId });
return data;
}
export async function createBillPayment(
fetcher: ApiFetcher,
values: CreateBillPaymentBody
): Promise<void> {
const post = fetcher.path(BILL_PAYMENTS_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editBillPayment(
fetcher: ApiFetcher,
billPaymentId: number,
values: EditBillPaymentBody
): Promise<void> {
const put = fetcher.path(BILL_PAYMENTS_ROUTES.BY_ID).method('put').create();
await put({ billPaymentId, ...values });
}
export async function deleteBillPayment(fetcher: ApiFetcher, billPaymentId: number): Promise<void> {
const del = fetcher.path(BILL_PAYMENTS_ROUTES.BY_ID).method('delete').create();
await del({ billPaymentId });
}
shared/sdk-ts/src/payment-receives.ts
+57
View File
@@ -0,0 +1,57 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const PAYMENTS_RECEIVED_ROUTES = {
LIST: '/api/payments-received',
BY_ID: '/api/payments-received/{id}',
STATE: '/api/payments-received/state',
VALIDATE_BULK_DELETE: '/api/payments-received/validate-bulk-delete',
BULK_DELETE: '/api/payments-received/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetPaymentsReceived = paths[typeof PAYMENTS_RECEIVED_ROUTES.LIST]['get'];
type GetPaymentReceived = paths[typeof PAYMENTS_RECEIVED_ROUTES.BY_ID]['get'];
type CreatePaymentReceived = paths[typeof PAYMENTS_RECEIVED_ROUTES.LIST]['post'];
type EditPaymentReceived = paths[typeof PAYMENTS_RECEIVED_ROUTES.BY_ID]['put'];
type DeletePaymentReceived = paths[typeof PAYMENTS_RECEIVED_ROUTES.BY_ID]['delete'];
type GetPaymentsReceived200 = GetPaymentsReceived['responses'][200];
type GetPaymentReceived200 = GetPaymentReceived['responses'][200];
export type PaymentsReceivedListResponse = GetPaymentsReceived200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type PaymentReceived = GetPaymentReceived200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreatePaymentReceivedBody = CreatePaymentReceived['requestBody']['content']['application/json'];
export type EditPaymentReceivedBody = EditPaymentReceived['requestBody']['content']['application/json'];
export async function fetchPaymentsReceived(fetcher: ApiFetcher): Promise<PaymentsReceivedListResponse> {
const get = fetcher.path(PAYMENTS_RECEIVED_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchPaymentReceived(fetcher: ApiFetcher, id: number): Promise<PaymentReceived> {
const get = fetcher.path(PAYMENTS_RECEIVED_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createPaymentReceived(
fetcher: ApiFetcher,
values: CreatePaymentReceivedBody
): Promise<void> {
const post = fetcher.path(PAYMENTS_RECEIVED_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editPaymentReceived(
fetcher: ApiFetcher,
id: number,
values: EditPaymentReceivedBody
): Promise<void> {
const put = fetcher.path(PAYMENTS_RECEIVED_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deletePaymentReceived(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(PAYMENTS_RECEIVED_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
shared/sdk-ts/src/roles.ts
+64
View File
@@ -0,0 +1,64 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const ROLES_ROUTES = {
LIST: '/api/roles',
BY_ID: '/api/roles/{id}',
PERMISSIONS_SCHEMA: '/api/roles/permissions/schema',
} as const satisfies Record<string, keyof paths>;
type GetRoles = paths[typeof ROLES_ROUTES.LIST]['get'];
type GetRole = paths[typeof ROLES_ROUTES.BY_ID]['get'];
type CreateRole = paths[typeof ROLES_ROUTES.LIST]['post'];
type EditRole = paths[typeof ROLES_ROUTES.BY_ID]['put'];
type DeleteRole = paths[typeof ROLES_ROUTES.BY_ID]['delete'];
type GetPermissionsSchema = paths[typeof ROLES_ROUTES.PERMISSIONS_SCHEMA]['get'];
type GetRoles200 = GetRoles['responses'][200];
type GetRole200 = GetRole['responses'][200];
type GetPermissionsSchema200 = GetPermissionsSchema['responses'][200];
export type RolesListResponse = GetRoles200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type Role = GetRole200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateRoleBody = CreateRole['requestBody']['content']['application/json'];
export type EditRoleBody = EditRole['requestBody']['content']['application/json'];
export type RolePermissionsSchema = GetPermissionsSchema200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export async function fetchRoles(fetcher: ApiFetcher): Promise<RolesListResponse> {
const get = fetcher.path(ROLES_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchRole(fetcher: ApiFetcher, id: number): Promise<Role> {
const get = fetcher.path(ROLES_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createRole(
fetcher: ApiFetcher,
values: CreateRoleBody
): Promise<void> {
const post = fetcher.path(ROLES_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editRole(
fetcher: ApiFetcher,
id: number,
values: EditRoleBody
): Promise<void> {
const put = fetcher.path(ROLES_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteRole(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(ROLES_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function fetchRolePermissionsSchema(fetcher: ApiFetcher): Promise<RolePermissionsSchema> {
const get = fetcher.path(ROLES_ROUTES.PERMISSIONS_SCHEMA).method('get').create();
const { data } = await get({});
return data;
}
shared/sdk-ts/src/sale-estimates.ts
+57
View File
@@ -0,0 +1,57 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const SALE_ESTIMATES_ROUTES = {
LIST: '/api/sale-estimates',
BY_ID: '/api/sale-estimates/{id}',
STATE: '/api/sale-estimates/state',
VALIDATE_BULK_DELETE: '/api/sale-estimates/validate-bulk-delete',
BULK_DELETE: '/api/sale-estimates/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetSaleEstimates = paths[typeof SALE_ESTIMATES_ROUTES.LIST]['get'];
type GetSaleEstimate = paths[typeof SALE_ESTIMATES_ROUTES.BY_ID]['get'];
type CreateSaleEstimate = paths[typeof SALE_ESTIMATES_ROUTES.LIST]['post'];
type EditSaleEstimate = paths[typeof SALE_ESTIMATES_ROUTES.BY_ID]['put'];
type DeleteSaleEstimate = paths[typeof SALE_ESTIMATES_ROUTES.BY_ID]['delete'];
type GetSaleEstimates200 = GetSaleEstimates['responses'][200];
type GetSaleEstimate200 = GetSaleEstimate['responses'][200];
export type SaleEstimatesListResponse = GetSaleEstimates200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type SaleEstimate = GetSaleEstimate200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateSaleEstimateBody = CreateSaleEstimate['requestBody']['content']['application/json'];
export type EditSaleEstimateBody = EditSaleEstimate['requestBody']['content']['application/json'];
export async function fetchSaleEstimates(fetcher: ApiFetcher): Promise<SaleEstimatesListResponse> {
const get = fetcher.path(SALE_ESTIMATES_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchSaleEstimate(fetcher: ApiFetcher, id: number): Promise<SaleEstimate> {
const get = fetcher.path(SALE_ESTIMATES_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createSaleEstimate(
fetcher: ApiFetcher,
values: CreateSaleEstimateBody
): Promise<void> {
const post = fetcher.path(SALE_ESTIMATES_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editSaleEstimate(
fetcher: ApiFetcher,
id: number,
values: EditSaleEstimateBody
): Promise<void> {
const put = fetcher.path(SALE_ESTIMATES_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteSaleEstimate(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(SALE_ESTIMATES_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
shared/sdk-ts/src/sale-invoices.ts
+63
View File
@@ -0,0 +1,63 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const SALE_INVOICES_ROUTES = {
LIST: '/api/sale-invoices',
BY_ID: '/api/sale-invoices/{id}',
STATE: '/api/sale-invoices/state',
RECEIVABLE: '/api/sale-invoices/receivable',
MAIL: '/api/sale-invoices/{id}/mail',
DELIVER: '/api/sale-invoices/{id}/deliver',
WRITEOFF: '/api/sale-invoices/{id}/writeoff',
CANCEL_WRITEOFF: '/api/sale-invoices/{id}/cancel-writeoff',
PAYMENTS: '/api/sale-invoices/{id}/payments',
HTML: '/api/sale-invoices/{id}/html',
GENERATE_LINK: '/api/sale-invoices/{id}/generate-link',
VALIDATE_BULK_DELETE: '/api/sale-invoices/validate-bulk-delete',
BULK_DELETE: '/api/sale-invoices/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetSaleInvoices = paths[typeof SALE_INVOICES_ROUTES.LIST]['get'];
type GetSaleInvoice = paths[typeof SALE_INVOICES_ROUTES.BY_ID]['get'];
type CreateSaleInvoice = paths[typeof SALE_INVOICES_ROUTES.LIST]['post'];
type EditSaleInvoice = paths[typeof SALE_INVOICES_ROUTES.BY_ID]['put'];
type DeleteSaleInvoice = paths[typeof SALE_INVOICES_ROUTES.BY_ID]['delete'];
export type SaleInvoicesListResponse = GetSaleInvoices['responses'][200]['content']['application/json'];
export type SaleInvoice = GetSaleInvoice['responses'][200]['content']['application/json'];
export type CreateSaleInvoiceBody = CreateSaleInvoice['requestBody']['content']['application/json'];
export type EditSaleInvoiceBody = EditSaleInvoice['requestBody']['content']['application/json'];
export async function fetchSaleInvoices(fetcher: ApiFetcher): Promise<SaleInvoicesListResponse> {
const get = fetcher.path(SALE_INVOICES_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchSaleInvoice(fetcher: ApiFetcher, id: number): Promise<SaleInvoice> {
const get = fetcher.path(SALE_INVOICES_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createSaleInvoice(
fetcher: ApiFetcher,
values: CreateSaleInvoiceBody
): Promise<void> {
const post = fetcher.path(SALE_INVOICES_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editSaleInvoice(
fetcher: ApiFetcher,
id: number,
values: EditSaleInvoiceBody
): Promise<void> {
const put = fetcher.path(SALE_INVOICES_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteSaleInvoice(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(SALE_INVOICES_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
shared/sdk-ts/src/sale-receipts.ts
+57
View File
@@ -0,0 +1,57 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const SALE_RECEIPTS_ROUTES = {
LIST: '/api/sale-receipts',
BY_ID: '/api/sale-receipts/{id}',
STATE: '/api/sale-receipts/state',
VALIDATE_BULK_DELETE: '/api/sale-receipts/validate-bulk-delete',
BULK_DELETE: '/api/sale-receipts/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetSaleReceipts = paths[typeof SALE_RECEIPTS_ROUTES.LIST]['get'];
type GetSaleReceipt = paths[typeof SALE_RECEIPTS_ROUTES.BY_ID]['get'];
type CreateSaleReceipt = paths[typeof SALE_RECEIPTS_ROUTES.LIST]['post'];
type EditSaleReceipt = paths[typeof SALE_RECEIPTS_ROUTES.BY_ID]['put'];
type DeleteSaleReceipt = paths[typeof SALE_RECEIPTS_ROUTES.BY_ID]['delete'];
type GetSaleReceipts200 = GetSaleReceipts['responses'][200];
type GetSaleReceipt200 = GetSaleReceipt['responses'][200];
export type SaleReceiptsListResponse = GetSaleReceipts200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type SaleReceipt = GetSaleReceipt200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateSaleReceiptBody = CreateSaleReceipt['requestBody']['content']['application/json'];
export type EditSaleReceiptBody = EditSaleReceipt['requestBody']['content']['application/json'];
export async function fetchSaleReceipts(fetcher: ApiFetcher): Promise<SaleReceiptsListResponse> {
const get = fetcher.path(SALE_RECEIPTS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchSaleReceipt(fetcher: ApiFetcher, id: number): Promise<SaleReceipt> {
const get = fetcher.path(SALE_RECEIPTS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createSaleReceipt(
fetcher: ApiFetcher,
values: CreateSaleReceiptBody
): Promise<void> {
const post = fetcher.path(SALE_RECEIPTS_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editSaleReceipt(
fetcher: ApiFetcher,
id: number,
values: EditSaleReceiptBody
): Promise<void> {
const put = fetcher.path(SALE_RECEIPTS_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteSaleReceipt(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(SALE_RECEIPTS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
shared/sdk-ts/src/schema.ts
+39792
View File
File diff suppressed because it is too large Load Diff
shared/sdk-ts/src/settings.ts
+28
View File
@@ -0,0 +1,28 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const SETTINGS_ROUTES = {
GET_SAVE: '/api/settings',
} as const satisfies Record<string, keyof paths>;
type GetSettings = paths[typeof SETTINGS_ROUTES.GET_SAVE]['get'];
type SaveSettings = paths[typeof SETTINGS_ROUTES.GET_SAVE]['put'];
type GetSettings200 = GetSettings['responses'][200];
type SaveSettingsRequestBody = SaveSettings extends { requestBody: { content: { 'application/json': infer J } } } ? J : Record<string, unknown>;
export type SettingsResponse = GetSettings200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type SaveSettingsBody = SaveSettingsRequestBody;
export async function fetchSettings(fetcher: ApiFetcher): Promise<SettingsResponse> {
const get = fetcher.path(SETTINGS_ROUTES.GET_SAVE).method('get').create();
const { data } = await get({});
return data;
}
export async function saveSettings(
fetcher: ApiFetcher,
values: SaveSettingsBody
): Promise<void> {
const put = fetcher.path(SETTINGS_ROUTES.GET_SAVE).method('put').create();
await put(values);
}
shared/sdk-ts/src/subscription.ts
+31
View File
@@ -0,0 +1,31 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const SUBSCRIPTION_ROUTES = {
LIST: '/api/subscription',
CHECKOUT_URL: '/api/subscription/lemon/checkout_url',
CANCEL: '/api/subscription/cancel',
RESUME: '/api/subscription/resume',
CHANGE: '/api/subscription/change',
} as const satisfies Record<string, keyof paths>;
type GetSubscriptions = paths[typeof SUBSCRIPTION_ROUTES.LIST]['get'];
type GetSubscriptions200 = GetSubscriptions['responses'][200];
export type SubscriptionsListResponse = GetSubscriptions200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export async function fetchSubscriptions(fetcher: ApiFetcher): Promise<SubscriptionsListResponse> {
const get = fetcher.path(SUBSCRIPTION_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function cancelSubscription(fetcher: ApiFetcher): Promise<void> {
const post = fetcher.path(SUBSCRIPTION_ROUTES.CANCEL).method('post').create();
await post({});
}
export async function resumeSubscription(fetcher: ApiFetcher): Promise<void> {
const post = fetcher.path(SUBSCRIPTION_ROUTES.RESUME).method('post').create();
await post({});
}
shared/sdk-ts/src/transactions-locking.ts
+24
View File
@@ -0,0 +1,24 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const TRANSACTIONS_LOCKING_ROUTES = {
LOCK: '/api/transactions-locking/lock',
CANCEL_LOCK: '/api/transactions-locking/cancel-lock',
UNLOCK_PARTIAL: '/api/transactions-locking/unlock-partial',
CANCEL_UNLOCK_PARTIAL: '/api/transactions-locking/cancel-unlock-partial',
LIST: '/api/transactions-locking',
BY_MODULE: '/api/transactions-locking/{module}',
} as const satisfies Record<string, keyof paths>;
export async function fetchTransactionsLocking(fetcher: ApiFetcher): Promise<void> {
const get = fetcher.path(TRANSACTIONS_LOCKING_ROUTES.LIST).method('get').create();
await get({});
}
export async function fetchTransactionsLockingByModule(
fetcher: ApiFetcher,
module: string
): Promise<void> {
const get = fetcher.path(TRANSACTIONS_LOCKING_ROUTES.BY_MODULE).method('get').create();
await get({ module });
}
shared/sdk-ts/src/users.ts
+60
View File
@@ -0,0 +1,60 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const USERS_ROUTES = {
LIST: '/api/users',
BY_ID: '/api/users/{id}',
ACTIVATE: '/api/users/{id}/activate',
INACTIVATE: '/api/users/{id}/inactivate',
} as const satisfies Record<string, keyof paths>;
type GetUsers = paths[typeof USERS_ROUTES.LIST]['get'];
type GetUser = paths[typeof USERS_ROUTES.BY_ID]['get'];
type EditUser = paths[typeof USERS_ROUTES.BY_ID]['put'];
type GetUsers200 = GetUsers['responses'][200];
type GetUser200 = GetUser['responses'][200];
export type UsersListResponse = GetUsers200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type User = GetUser200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type EditUserBody = EditUser['requestBody']['content']['application/json'];
export type GetUsersQuery = GetUsers['parameters']['query'];
export async function fetchUsers(
fetcher: ApiFetcher,
query: GetUsersQuery = { page: 1, page_size: 20 }
): Promise<UsersListResponse> {
const get = fetcher.path(USERS_ROUTES.LIST).method('get').create();
const { data } = await get(query);
return data;
}
export async function fetchUser(fetcher: ApiFetcher, id: number): Promise<User> {
const get = fetcher.path(USERS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function editUser(
fetcher: ApiFetcher,
id: number,
values: EditUserBody
): Promise<void> {
const put = fetcher.path(USERS_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteUser(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(USERS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function activateUser(fetcher: ApiFetcher, id: number): Promise<void> {
const put = fetcher.path(USERS_ROUTES.ACTIVATE).method('put').create();
await (put as (params: { id: number }) => ReturnType<typeof put>)({ id });
}
export async function inactivateUser(fetcher: ApiFetcher, id: number): Promise<void> {
const put = fetcher.path(USERS_ROUTES.INACTIVATE).method('put').create();
await (put as (params: { id: number }) => ReturnType<typeof put>)({ id });
}
shared/sdk-ts/src/vendor-credits.ts
+62
View File
@@ -0,0 +1,62 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const VENDOR_CREDITS_ROUTES = {
LIST: '/api/vendor-credits',
BY_ID: '/api/vendor-credits/{id}',
OPEN: '/api/vendor-credits/{id}/open',
VALIDATE_BULK_DELETE: '/api/vendor-credits/validate-bulk-delete',
BULK_DELETE: '/api/vendor-credits/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetVendorCredits = paths[typeof VENDOR_CREDITS_ROUTES.LIST]['get'];
type GetVendorCredit = paths[typeof VENDOR_CREDITS_ROUTES.BY_ID]['get'];
type CreateVendorCredit = paths[typeof VENDOR_CREDITS_ROUTES.LIST]['post'];
type EditVendorCredit = paths[typeof VENDOR_CREDITS_ROUTES.BY_ID]['put'];
type DeleteVendorCredit = paths[typeof VENDOR_CREDITS_ROUTES.BY_ID]['delete'];
type GetVendorCredits200 = GetVendorCredits['responses'][200];
type GetVendorCredit200 = GetVendorCredit['responses'][200];
export type VendorCreditsListResponse = GetVendorCredits200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type VendorCredit = GetVendorCredit200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateVendorCreditBody = CreateVendorCredit['requestBody']['content']['application/json'];
export type EditVendorCreditBody = EditVendorCredit['requestBody']['content']['application/json'];
export async function fetchVendorCredits(fetcher: ApiFetcher): Promise<VendorCreditsListResponse> {
const get = fetcher.path(VENDOR_CREDITS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchVendorCredit(fetcher: ApiFetcher, id: number): Promise<VendorCredit> {
const get = fetcher.path(VENDOR_CREDITS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createVendorCredit(
fetcher: ApiFetcher,
values: CreateVendorCreditBody
): Promise<void> {
const post = fetcher.path(VENDOR_CREDITS_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editVendorCredit(
fetcher: ApiFetcher,
id: number,
values: EditVendorCreditBody
): Promise<void> {
const put = fetcher.path(VENDOR_CREDITS_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteVendorCredit(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(VENDOR_CREDITS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function openVendorCredit(fetcher: ApiFetcher, id: number): Promise<void> {
const put = fetcher.path(VENDOR_CREDITS_ROUTES.OPEN).method('put').create();
await put({ id });
}
shared/sdk-ts/src/vendors.ts
+77
View File
@@ -0,0 +1,77 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const VENDORS_ROUTES = {
LIST: '/api/vendors',
BY_ID: '/api/vendors/{id}',
OPENING_BALANCE: '/api/vendors/{id}/opening-balance',
VALIDATE_BULK_DELETE: '/api/vendors/validate-bulk-delete',
BULK_DELETE: '/api/vendors/bulk-delete',
} as const satisfies Record<string, keyof paths>;
type GetVendors = paths[typeof VENDORS_ROUTES.LIST]['get'];
type GetVendor = paths[typeof VENDORS_ROUTES.BY_ID]['get'];
type CreateVendor = paths[typeof VENDORS_ROUTES.LIST]['post'];
type EditVendor = paths[typeof VENDORS_ROUTES.BY_ID]['put'];
type ValidateBulkDelete = paths[typeof VENDORS_ROUTES.VALIDATE_BULK_DELETE]['post'];
type BulkDelete = paths[typeof VENDORS_ROUTES.BULK_DELETE]['post'];
type GetVendors200 = GetVendors['responses'][200];
type GetVendor200 = GetVendor['responses'][200];
export type VendorsListResponse = GetVendors200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type Vendor = GetVendor200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateVendorBody = CreateVendor['requestBody']['content']['application/json'];
export type EditVendorBody = EditVendor['requestBody']['content']['application/json'];
export type ValidateBulkDeleteVendorsResponse = ValidateBulkDelete['responses'][200]['content']['application/json'];
export type BulkDeleteVendorsBody = BulkDelete['requestBody']['content']['application/json'];
export async function fetchVendors(fetcher: ApiFetcher): Promise<VendorsListResponse> {
const get = fetcher.path(VENDORS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchVendor(fetcher: ApiFetcher, id: number): Promise<Vendor> {
const get = fetcher.path(VENDORS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createVendor(
fetcher: ApiFetcher,
values: CreateVendorBody
): Promise<void> {
const post = fetcher.path(VENDORS_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editVendor(
fetcher: ApiFetcher,
id: number,
values: EditVendorBody
): Promise<void> {
const put = fetcher.path(VENDORS_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteVendor(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(VENDORS_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function validateBulkDeleteVendors(
fetcher: ApiFetcher,
body: BulkDeleteVendorsBody
): Promise<ValidateBulkDeleteVendorsResponse> {
const validate = fetcher.path(VENDORS_ROUTES.VALIDATE_BULK_DELETE).method('post').create();
const { data } = await validate(body);
return data;
}
export async function bulkDeleteVendors(
fetcher: ApiFetcher,
body: BulkDeleteVendorsBody
): Promise<void> {
const post = fetcher.path(VENDORS_ROUTES.BULK_DELETE).method('post').create();
await post(body);
}
shared/sdk-ts/src/views.ts
+20
View File
@@ -0,0 +1,20 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const VIEWS_ROUTES = {
RESOURCE: '/api/views/resource/{resourceModel}',
} as const satisfies Record<string, keyof paths>;
type GetResourceView = paths[typeof VIEWS_ROUTES.RESOURCE]['get'];
type GetResourceView200 = GetResourceView['responses'][200];
export type ResourceViewResponse = GetResourceView200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export async function fetchResourceView(
fetcher: ApiFetcher,
resourceModel: string
): Promise<ResourceViewResponse> {
const get = fetcher.path(VIEWS_ROUTES.RESOURCE).method('get').create();
const { data } = await get({ resourceModel });
return data;
}
shared/sdk-ts/src/warehouse-transfers.ts
+68
View File
@@ -0,0 +1,68 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const WAREHOUSE_TRANSFERS_ROUTES = {
LIST: '/api/warehouse-transfers',
BY_ID: '/api/warehouse-transfers/{id}',
INITIATE: '/api/warehouse-transfers/{id}/initiate',
TRANSFERRED: '/api/warehouse-transfers/{id}/transferred',
} as const satisfies Record<string, keyof paths>;
type GetWarehouseTransfers = paths[typeof WAREHOUSE_TRANSFERS_ROUTES.LIST]['get'];
type GetWarehouseTransfer = paths[typeof WAREHOUSE_TRANSFERS_ROUTES.BY_ID]['get'];
type CreateWarehouseTransfer = paths[typeof WAREHOUSE_TRANSFERS_ROUTES.LIST]['post'];
type EditWarehouseTransfer = paths[typeof WAREHOUSE_TRANSFERS_ROUTES.BY_ID]['put'];
type DeleteWarehouseTransfer = paths[typeof WAREHOUSE_TRANSFERS_ROUTES.BY_ID]['delete'];
type GetWarehouseTransfers200 = GetWarehouseTransfers['responses'][200];
type GetWarehouseTransfer200 = GetWarehouseTransfer['responses'][200];
export type WarehouseTransfersListResponse = GetWarehouseTransfers200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type WarehouseTransfer = GetWarehouseTransfer200 extends { content?: { 'application/json': infer J } } ? J : unknown;
export type CreateBody = CreateWarehouseTransfer extends { requestBody: { content: { 'application/json': infer J } } } ? J : Record<string, unknown>;
type EditBody = EditWarehouseTransfer extends { requestBody: { content: { 'application/json': infer J } } } ? J : Record<string, unknown>;
export type CreateWarehouseTransferBody = CreateBody;
export type EditWarehouseTransferBody = EditBody;
export async function fetchWarehouseTransfers(fetcher: ApiFetcher): Promise<WarehouseTransfersListResponse> {
const get = fetcher.path(WAREHOUSE_TRANSFERS_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchWarehouseTransfer(fetcher: ApiFetcher, id: number): Promise<WarehouseTransfer> {
const get = fetcher.path(WAREHOUSE_TRANSFERS_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createWarehouseTransfer(
fetcher: ApiFetcher,
values: CreateWarehouseTransferBody
): Promise<void> {
const post = fetcher.path(WAREHOUSE_TRANSFERS_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editWarehouseTransfer(
fetcher: ApiFetcher,
id: number,
values: EditWarehouseTransferBody
): Promise<void> {
const put = fetcher.path(WAREHOUSE_TRANSFERS_ROUTES.BY_ID).method('put').create();
await (put as unknown as (params: { id: number } & EditWarehouseTransferBody) => Promise<void>)({ id, ...values });
}
export async function deleteWarehouseTransfer(fetcher: ApiFetcher, id: number): Promise<void> {
const del = fetcher.path(WAREHOUSE_TRANSFERS_ROUTES.BY_ID).method('delete').create();
await (del as unknown as (params: { id: number }) => Promise<void>)({ id });
}
export async function initiateWarehouseTransfer(fetcher: ApiFetcher, id: number): Promise<void> {
const put = fetcher.path(WAREHOUSE_TRANSFERS_ROUTES.INITIATE).method('put').create();
await (put as unknown as (params: { id: number }) => Promise<void>)({ id });
}
export async function transferredWarehouseTransfer(fetcher: ApiFetcher, id: number): Promise<void> {
const put = fetcher.path(WAREHOUSE_TRANSFERS_ROUTES.TRANSFERRED).method('put').create();
await (put as unknown as (params: { id: number }) => Promise<void>)({ id });
}
shared/sdk-ts/src/warehouses.ts
+64
View File
@@ -0,0 +1,64 @@
import type { ApiFetcher } from './fetch-utils';
import type { paths } from './schema';
export const WAREHOUSES_ROUTES = {
LIST: '/api/warehouses',
BY_ID: '/api/warehouses/{id}',
ACTIVATE: '/api/warehouses/activate',
MARK_PRIMARY: '/api/warehouses/{id}/mark-primary',
} as const satisfies Record<string, keyof paths>;
type GetWarehouses = paths[typeof WAREHOUSES_ROUTES.LIST]['get'];
type GetWarehouse = paths[typeof WAREHOUSES_ROUTES.BY_ID]['get'];
type CreateWarehouse = paths[typeof WAREHOUSES_ROUTES.LIST]['post'];
type EditWarehouse = paths[typeof WAREHOUSES_ROUTES.BY_ID]['put'];
type DeleteWarehouse = paths[typeof WAREHOUSES_ROUTES.BY_ID]['delete'];
export type WarehousesListResponse = GetWarehouses['responses'][200]['content']['application/json'];
export type Warehouse = GetWarehouse['responses'][200]['content']['application/json'];
export type CreateWarehouseBody = CreateWarehouse['requestBody']['content']['application/json'];
export type EditWarehouseBody = EditWarehouse['requestBody']['content']['application/json'];
export async function fetchWarehouses(fetcher: ApiFetcher): Promise<WarehousesListResponse> {
const get = fetcher.path(WAREHOUSES_ROUTES.LIST).method('get').create();
const { data } = await get({});
return data;
}
export async function fetchWarehouse(fetcher: ApiFetcher, id: string): Promise<Warehouse> {
const get = fetcher.path(WAREHOUSES_ROUTES.BY_ID).method('get').create();
const { data } = await get({ id });
return data;
}
export async function createWarehouse(
fetcher: ApiFetcher,
values: CreateWarehouseBody
): Promise<void> {
const post = fetcher.path(WAREHOUSES_ROUTES.LIST).method('post').create();
await post(values);
}
export async function editWarehouse(
fetcher: ApiFetcher,
id: string,
values: EditWarehouseBody
): Promise<void> {
const put = fetcher.path(WAREHOUSES_ROUTES.BY_ID).method('put').create();
await put({ id, ...values });
}
export async function deleteWarehouse(fetcher: ApiFetcher, id: string): Promise<void> {
const del = fetcher.path(WAREHOUSES_ROUTES.BY_ID).method('delete').create();
await del({ id });
}
export async function activateWarehouses(fetcher: ApiFetcher): Promise<void> {
const post = fetcher.path(WAREHOUSES_ROUTES.ACTIVATE).method('post').create();
await post({});
}
export async function markWarehousePrimary(fetcher: ApiFetcher, id: string): Promise<void> {
const put = fetcher.path(WAREHOUSES_ROUTES.MARK_PRIMARY).method('put').create();
await put({ id });
}
shared/sdk-ts/tsconfig.json
+16
View File
@@ -0,0 +1,16 @@
{
"compilerOptions": {
"target": "ES2020",
"module": "ESNext",
"moduleResolution": "node",
"outDir": "dist",
"declaration": true,
"declarationDir": "dist",
"strict": true,
"skipLibCheck": true,
"esModuleInterop": true,
"forceConsistentCasingInFileNames": true
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist"]
}