@simpleapps-com/augur-api
Version:
TypeScript client library for Augur microservices API endpoints
405 lines • 18.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createWarehouseResource = createWarehouseResource;
exports.createWarehouseDataResource = createWarehouseDataResource;
const zod_1 = require("zod");
const schemas_1 = require("../schemas");
/**
* Creates the warehouse resource methods
* OpenAPI Path: /warehouse → warehouse.*
* @description Methods for CRUD operations on warehouses and warehouse configuration
*/
function createWarehouseResource(executeRequest) {
const resource = {
/**
* List warehouses with filtering and pagination
* @description Returns warehouses with optional filtering by customer, user access, and status
* @param params Optional filtering and pagination parameters
* @returns Array of warehouse objects with pagination metadata
* @throws ValidationError When parameters are invalid or response is malformed
*/
list: async (params) => {
return executeRequest({
method: 'GET',
path: '/warehouse',
paramsSchema: schemas_1.WarehouseListParamsSchema,
responseSchema: schemas_1.WarehouseListResponseSchema,
}, params);
},
/**
* Get warehouse details by ID
* @description Returns detailed information for a specific warehouse
* @param warehouseUid Warehouse unique identifier
* @returns Warehouse details
* @throws ValidationError When response is malformed
*/
get: async (warehouseUid) => {
return executeRequest({
method: 'GET',
path: `/warehouse/${warehouseUid}`,
responseSchema: schemas_1.WarehouseResponseSchema,
}, undefined);
},
/**
* Create a new warehouse
* @description Creates a new warehouse with specified configuration
* @param request Warehouse creation data
* @returns Created warehouse information
* @throws ValidationError When request is invalid or response is malformed
*/
create: async (request) => {
return executeRequest({
method: 'POST',
path: '/warehouse',
paramsSchema: schemas_1.CreateWarehouseRequestSchema,
responseSchema: schemas_1.WarehouseResponseSchema,
}, request);
},
/**
* Update an existing warehouse
* @description Updates warehouse information with provided data
* @param warehouseUid Warehouse unique identifier
* @param request Warehouse update data
* @returns Updated warehouse information
* @throws ValidationError When request is invalid or response is malformed
*/
update: async (warehouseUid, request) => {
return executeRequest({
method: 'PUT',
path: `/warehouse/${warehouseUid}`,
paramsSchema: schemas_1.UpdateWarehouseRequestSchema,
responseSchema: schemas_1.WarehouseResponseSchema,
}, request);
},
/**
* Soft delete a warehouse
* @description Marks warehouse as deleted (sets status_cd to 700) without removing data
* @param warehouseUid Warehouse unique identifier
* @returns Boolean indicating successful deletion
* @throws ValidationError When response is malformed
*/
delete: async (warehouseUid) => {
await executeRequest({
method: 'DELETE',
path: `/warehouse/${warehouseUid}`,
responseSchema: zod_1.z.unknown(),
});
return true;
},
/**
* Enable, disable, or delete a warehouse
* @description Changes warehouse status using status codes (704=active, 705=inactive, 700=deleted)
* @param warehouseUid Warehouse unique identifier
* @param request Status change request with new status code
* @returns Updated warehouse information
* @throws ValidationError When request is invalid or response is malformed
*/
enable: async (warehouseUid, request) => {
return executeRequest({
method: 'PUT',
path: '/warehouse/{warehouseUid}/enable',
paramsSchema: schemas_1.EnableWarehouseRequestSchema,
responseSchema: schemas_1.WarehouseResponseSchema,
}, request, { warehouseUid: String(warehouseUid) });
},
/**
* Warehouse availability endpoints
* @description Methods for checking inventory availability in warehouses
*/
availability: {
/**
* Check inventory availability with search
* @description Searches inventory items in a warehouse with query string matching
* @param warehouseUid Warehouse unique identifier
* @param params Search parameters including required query string
* @returns Array of available inventory items matching search criteria
* @throws ValidationError When parameters are invalid or response is malformed
*/
get: async (warehouseUid, params) => {
return executeRequest({
method: 'GET',
path: '/warehouse/{warehouseUid}/availability',
paramsSchema: schemas_1.InventoryAvailabilityParamsSchema,
responseSchema: schemas_1.InventoryAvailabilityResponseSchema,
}, params, { warehouseUid: String(warehouseUid) });
},
},
/**
* Warehouse adjust endpoints
* @description Methods for adjusting inventory quantities
*/
adjust: {
/**
* Adjust inventory quantities
* @description Sets absolute inventory quantities (not relative changes) with optional reason tracking
* @param warehouseUid Warehouse unique identifier
* @param request Adjustment request containing array of inventory adjustments
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
*/
create: async (warehouseUid, request) => {
await executeRequest({
method: 'POST',
path: '/warehouse/{warehouseUid}/adjust',
paramsSchema: schemas_1.InventoryAdjustRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { warehouseUid: String(warehouseUid) });
return true;
},
},
/**
* Warehouse receive endpoints
* @description Methods for receiving inventory into warehouses
*/
receive: {
/**
* Receive inventory into warehouse
* @description Records received inventory with optional purchase order and lot tracking
* @param warehouseUid Warehouse unique identifier
* @param request Receive request containing array of inventory receipts
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
*/
create: async (warehouseUid, request) => {
await executeRequest({
method: 'POST',
path: '/warehouse/{warehouseUid}/receive',
paramsSchema: schemas_1.InventoryReceiveRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { warehouseUid: String(warehouseUid) });
return true;
},
},
/**
* Warehouse replenish endpoints
* @description Methods for warehouse replenishment operations
*/
replenish: {
/**
* Get replenishment information
* @description Returns items that need replenishment based on min/max quantities
* @param warehouseUid Warehouse unique identifier
* @param params Optional filtering by distributor
* @returns Replenishment information with suggested order quantities
* @throws ValidationError When parameters are invalid or response is malformed
*/
get: async (warehouseUid, params) => {
return executeRequest({
method: 'GET',
path: '/warehouse/{warehouseUid}/replenish',
paramsSchema: schemas_1.ReplenishmentParamsSchema,
responseSchema: schemas_1.ReplenishmentInfoResponseSchema,
}, params, { warehouseUid: String(warehouseUid) });
},
/**
* Execute inventory replenishment
* @description Places replenishment orders based on min/max/reorder quantities
* @param warehouseUid Warehouse unique identifier
* @param request Replenishment request with distributor and items to restock
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
*/
create: async (warehouseUid, request) => {
await executeRequest({
method: 'POST',
path: '/warehouse/{warehouseUid}/replenish',
paramsSchema: schemas_1.ReplenishRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { warehouseUid: String(warehouseUid) });
return true;
},
},
/**
* Warehouse transfer endpoints
* @description Methods for transferring inventory between warehouses
*/
transfer: {
/**
* Transfer inventory between warehouses
* @description Moves inventory from one warehouse to another with quantity tracking
* @param warehouseUid Source warehouse unique identifier
* @param request Transfer request with destination warehouse and items to transfer
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
*/
create: async (warehouseUid, request) => {
await executeRequest({
method: 'POST',
path: '/warehouse/{warehouseUid}/transfer',
paramsSchema: schemas_1.TransferRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { warehouseUid: String(warehouseUid) });
return true;
},
},
/**
* Warehouse usage endpoints
* @description Methods for recording inventory usage
*/
usage: {
/**
* Record inventory usage
* @description Automatically decrements inventory and creates usage records for job tracking
* @param warehouseUid Warehouse unique identifier
* @param request Usage request with job information and consumed items
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
*/
create: async (warehouseUid, request) => {
await executeRequest({
method: 'POST',
path: '/warehouse/{warehouseUid}/usage',
paramsSchema: schemas_1.UsageRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { warehouseUid: String(warehouseUid) });
return true;
},
},
/**
* Warehouse users endpoints
* @description Methods for managing user access permissions to warehouses
*/
users: {
/**
* List users with access to specific warehouse
* @description Returns users who have access to a warehouse with optional status filtering
* @param warehouseUid Warehouse unique identifier
* @param params Optional filtering and pagination parameters
* @returns Array of warehouse user access records
* @throws ValidationError When parameters are invalid or response is malformed
*/
list: async (warehouseUid, params) => {
return executeRequest({
method: 'GET',
path: '/warehouse/{warehouseUid}/users',
paramsSchema: schemas_1.WarehouseUserListParamsSchema,
responseSchema: schemas_1.WarehouseUserListResponseSchema,
}, params, { warehouseUid: String(warehouseUid) });
},
/**
* Create or update warehouse user access
* @description Grants or updates user access to a warehouse with optional primary user designation
* @param warehouseUid Warehouse unique identifier
* @param request User access request data
* @returns Created or updated warehouse user access information
* @throws ValidationError When request is invalid or response is malformed
*/
create: async (warehouseUid, request) => {
return executeRequest({
method: 'POST',
path: '/warehouse/{warehouseUid}/users',
paramsSchema: schemas_1.CreateWarehouseUserRequestSchema,
responseSchema: schemas_1.WarehouseUserResponseSchema,
}, request, { warehouseUid: String(warehouseUid) });
},
/**
* Get warehouse user assignment details
* @description Returns user assignment details for a specific user in a warehouse
* @param warehouseUid Warehouse unique identifier
* @param usersId User unique identifier
* @returns Warehouse user assignment details
* @throws ValidationError When response is malformed
*/
get: async (warehouseUid, usersId) => {
return executeRequest({
method: 'GET',
path: '/warehouse/{warehouseUid}/users/{usersId}',
paramsSchema: schemas_1.WarehouseUserDetailParamsSchema,
responseSchema: schemas_1.WarehouseUserResponseSchema,
}, { warehouseUid, usersId }, { warehouseUid: String(warehouseUid), usersId: String(usersId) });
},
/**
* Update warehouse user assignment
* @description Updates user assignment status or primary user designation
* @param warehouseUid Warehouse unique identifier
* @param usersId User unique identifier
* @param request Update request data
* @returns Updated warehouse user assignment
* @throws ValidationError When request is invalid or response is malformed
*/
update: async (warehouseUid, usersId, request) => {
return executeRequest({
method: 'PUT',
path: '/warehouse/{warehouseUid}/users/{usersId}',
paramsSchema: schemas_1.UpdateWarehouseUserRequestSchema,
responseSchema: schemas_1.WarehouseUserResponseSchema,
}, request, { warehouseUid: String(warehouseUid), usersId: String(usersId) });
},
/**
* Remove user from warehouse
* @description Removes user access from warehouse (sets status_cd to 700)
* @param warehouseUid Warehouse unique identifier
* @param usersId User unique identifier
* @returns Boolean indicating successful removal
* @throws ValidationError When response is malformed
*/
delete: async (warehouseUid, usersId) => {
await executeRequest({
method: 'DELETE',
path: '/warehouse/{warehouseUid}/users/{usersId}',
responseSchema: zod_1.z.unknown(),
}, undefined, { warehouseUid: String(warehouseUid), usersId: String(usersId) });
return true;
},
},
};
return resource;
}
/**
* Creates the warehouseData resource methods (data-only versions)
*/
function createWarehouseDataResource(warehouse) {
return {
list: async (params) => {
const response = await warehouse.list(params);
return response.data;
},
get: async (warehouseUid) => {
const response = await warehouse.get(warehouseUid);
return response.data;
},
create: async (request) => {
const response = await warehouse.create(request);
return response.data;
},
update: async (warehouseUid, request) => {
const response = await warehouse.update(warehouseUid, request);
return response.data;
},
enable: async (warehouseUid, request) => {
const response = await warehouse.enable(warehouseUid, request);
return response.data;
},
availability: {
get: async (warehouseUid, params) => {
const response = await warehouse.availability.get(warehouseUid, params);
return response.data;
},
},
replenish: {
get: async (warehouseUid, params) => {
const response = await warehouse.replenish.get(warehouseUid, params);
return response.data;
},
},
users: {
list: async (warehouseUid, params) => {
const response = await warehouse.users.list(warehouseUid, params);
return response.data;
},
create: async (warehouseUid, request) => {
const response = (await warehouse.users.create(warehouseUid, request));
return response.data;
},
get: async (warehouseUid, usersId) => {
const response = await warehouse.users.get(warehouseUid, usersId);
return response.data;
},
update: async (warehouseUid, usersId, request) => {
const response = await warehouse.users.update(warehouseUid, usersId, request);
return response.data;
},
},
};
}
//# sourceMappingURL=warehouse.js.map