diff options
Diffstat (limited to 'nodejs/lib')
| -rw-r--r-- | nodejs/lib/api.ts | 35 | ||||
| -rw-r--r-- | nodejs/lib/contracts.ts | 43 | ||||
| -rw-r--r-- | nodejs/lib/errors.ts | 35 | ||||
| -rw-r--r-- | nodejs/lib/ships.ts | 405 | ||||
| -rw-r--r-- | nodejs/lib/systems.ts | 32 | ||||
| -rw-r--r-- | nodejs/lib/types.ts | 145 | ||||
| -rw-r--r-- | nodejs/lib/utils.ts | 2 |
7 files changed, 442 insertions, 255 deletions
diff --git a/nodejs/lib/api.ts b/nodejs/lib/api.ts index f023ccf..2bb81a6 100644 --- a/nodejs/lib/api.ts +++ b/nodejs/lib/api.ts @@ -3,8 +3,39 @@ import events from 'events'; import { PriorityQueue } from './priority_queue.ts'; import { getToken } from '../database/tokens.ts'; -import { APIError, Request, RequestPromise, Response } from '../model/api.ts'; -import { RateLimitError } from '../model/errors.ts'; +import { RateLimitError } from './errors.ts'; + +export type APIError = { + error: string; + code: number; + data: unknown; +}; + +export type Meta = { + limit: number; + page: number; + total: number; +} + +export type Request = { + endpoint: string; // the path part of the url to call + method?: string; // HTTP method for `fetch` call, defaults to 'GET' + page?: number; // run a paginated request starting from this page until all the following pages are fetched + payload?: { [key:string]: any}; // optional json object that will be sent along the request + priority?: number; // optional priority value, defaults to 10. lower than 10 means the message will be sent faster +}; + +export type RequestPromise<T> = { + reject: (reason?: any) => void; + request: Request; + resolve: (value: Response<T> | PromiseLike<Response<T>>) => void; +}; + +export type Response<T> = { + data: T; + error?: APIError; + meta?: Meta; +} // queue processor module variables const bus = new events.EventEmitter(); // a bus to notify the queue processor to start processing messages diff --git a/nodejs/lib/contracts.ts b/nodejs/lib/contracts.ts index 2b6f877..833d434 100644 --- a/nodejs/lib/contracts.ts +++ b/nodejs/lib/contracts.ts @@ -1,20 +1,24 @@ -import { Agent } from '../model/agent.ts'; -import { APIError } from '../model/api.ts'; -import { Cargo } from '../model/cargo.ts'; -import { Contract } from '../model/contract.ts'; -import { Ship } from '../model/ship.ts'; +import { + Agent, + Cargo, + Contract, +} from './types.ts'; +import { + APIError, + debugLog, + send, + sendPaginated, +} from './api.ts'; +import { Ship } from './ships.ts'; import * as dbAgents from '../database/agents.ts'; import * as dbContracts from '../database/contracts.ts'; -import * as api from './api.ts'; -import * as dbShips from '../database/ships.ts'; -import * as libShips from '../lib/ships.ts'; export async function accept(contract: Contract): Promise<Contract> { contract = dbContracts.getContract(contract.id); if (contract.accepted) return contract; - const response = await api.send<{agent: Agent, contract: Contract, type: ''}>({endpoint: `/my/contracts/${contract.id}/accept`, method: 'POST'}); + const response = await send<{agent: Agent, contract: Contract, type: ''}>({endpoint: `/my/contracts/${contract.id}/accept`, method: 'POST'}); if (response.error) { - api.debugLog(response); + debugLog(response); throw response; } dbAgents.setAgent(response.data.agent); @@ -23,7 +27,7 @@ export async function accept(contract: Contract): Promise<Contract> { } export async function getContracts(): Promise<Array<Contract>> { - const response = await api.sendPaginated<Contract>({endpoint: '/my/contracts'}); + const response = await sendPaginated<Contract>({endpoint: '/my/contracts'}); response.forEach(contract => dbContracts.setContract(contract)); return response; } @@ -32,9 +36,9 @@ export async function getContract(contract: Contract): Promise<Contract> { try { return dbContracts.getContract(contract.id); } catch {} - const response = await api.send<Contract>({endpoint: `/my/contracts/${contract.id}`}); + const response = await send<Contract>({endpoint: `/my/contracts/${contract.id}`}); if (response.error) { - api.debugLog(response); + debugLog(response); throw response; } dbContracts.setContract(response.data); @@ -43,15 +47,14 @@ export async function getContract(contract: Contract): Promise<Contract> { export async function deliver(contract: Contract, ship: Ship): Promise<Contract> { contract = dbContracts.getContract(contract.id); - ship = dbShips.getShip(ship.symbol); if (contract.terms.deliver[0].unitsRequired <= contract.terms.deliver[0].unitsFulfilled) { return await fulfill(contract); } const tradeSymbol = contract.terms.deliver[0].tradeSymbol; let units = 0; ship.cargo.inventory.forEach(i => {if (i.symbol === tradeSymbol) units = i.units; }); - await libShips.dock(ship); // we need to be docked to deliver - const response = await api.send<{contract: Contract, cargo: Cargo}>({ endpoint: `/my/contracts/${contract.id}/deliver`, method: 'POST', payload: { + await ship.dock(); // we need to be docked to deliver + const response = await send<{contract: Contract, cargo: Cargo}>({ endpoint: `/my/contracts/${contract.id}/deliver`, method: 'POST', payload: { shipSymbol: ship.symbol, tradeSymbol: tradeSymbol, units: units, @@ -61,12 +64,12 @@ export async function deliver(contract: Contract, ship: Ship): Promise<Contract> case 4509: // contract delivery terms have been met return await fulfill(contract); default: // yet unhandled error - api.debugLog(response); + debugLog(response); throw response; } } dbContracts.setContract(response.data.contract); - dbShips.setShipCargo(ship.symbol, response.data.cargo); + ship.cargo = response.data.cargo; if(response.data.contract.terms.deliver[0].unitsRequired <= response.data.contract.terms.deliver[0].unitsFulfilled) { return await fulfill(response.data.contract); } @@ -76,9 +79,9 @@ export async function deliver(contract: Contract, ship: Ship): Promise<Contract> export async function fulfill(contract: Contract): Promise<Contract> { contract = dbContracts.getContract(contract.id); if (contract.fulfilled) return contract; - const response = await api.send<{agent: Agent, contract: Contract}>({ endpoint: `/my/contracts/${contract.id}/fulfill`, method: 'POST'}); + const response = await send<{agent: Agent, contract: Contract}>({ endpoint: `/my/contracts/${contract.id}/fulfill`, method: 'POST'}); if (response.error) { - api.debugLog(response); + debugLog(response); throw response; } dbAgents.setAgent(response.data.agent); diff --git a/nodejs/lib/errors.ts b/nodejs/lib/errors.ts new file mode 100644 index 0000000..f9dca89 --- /dev/null +++ b/nodejs/lib/errors.ts @@ -0,0 +1,35 @@ +import { Cooldown } from './types.ts'; + +export type MarketTradeVolumeError = { + waypointSymbol: string; + tradeSymbol: string; + units: number; + tradeVolume: number; +}; + +export type RateLimitError = { + type: string; + retryAfter: number; + limitBurst: number; + limitPerSecond: number; + remaining: number; + reset: Date; +}; + +export type ShipIsCurrentlyInTransitError = { + arrival: Date; + departureSymbol: string; + departureTime: Date; + destinationSymbol: string; + secondsToArrival: number; +}; + +export type ShipIsStillOnCooldownError = { + cooldown: Cooldown; +}; + +export type ShipRequiresMoreFuelForNavigationError = { + fuelAvailable: number; + fuelRequired: number; + shipSymbol: string; +}; diff --git a/nodejs/lib/ships.ts b/nodejs/lib/ships.ts index 83b2e86..7221596 100644 --- a/nodejs/lib/ships.ts +++ b/nodejs/lib/ships.ts @@ -1,240 +1,207 @@ -import { Response } from '../model/api.ts'; -import { Agent } from '../model/agent.ts'; -import { Cargo } from '../model/cargo.ts'; -import { Contract } from '../model/contract.ts'; -import { Cooldown, Fuel, Nav, Ship } from '../model/ship.ts'; -import * as api from './api.ts'; +import { + Response, + debugLog, + send, + sleep, +} from './api.ts'; +import { + MarketTradeVolumeError, + ShipIsCurrentlyInTransitError, + ShipIsStillOnCooldownError, + ShipRequiresMoreFuelForNavigationError, +} from './errors.ts'; +import { + Agent, + Cargo, + Contract, + Cooldown, + Fuel, + Nav, + Registration, +} from './types.ts'; import * as dbAgents from '../database/agents.ts'; -import * as dbShips from '../database/ships.ts'; -//import * as dbSurveys from '../database/surveys.ts'; -import * as systems from '../lib/systems.ts'; -export async function buy(ship: Ship, tradeSymbol: string, units: number): Promise<void> { - if (units <= 0) return; - ship = await getShip(ship); - await dock(ship); - // TODO take into account the tradevolume, we might need to buy in multiple steps - const response = await api.send<{agent: Agent, cargo: Cargo}>({endpoint: `/my/ships/${ship.symbol}/purchase`, method: 'POST', payload: { symbol: tradeSymbol, units: units }}); // TODO transaction field +export async function getShips(): Promise<Array<Ship>> { + const response = await send<Array<Ship>>({endpoint: `/my/ships`, page: 1}); if (response.error) { - api.debugLog(response); + debugLog(response); throw response; } - dbShips.setShipCargo(ship.symbol, response.data.cargo); - dbAgents.setAgent(response.data.agent); + return response.data.map(ship => new Ship(ship)); } -export async function dock(ship: Ship): Promise<void> { - ship = await getShip(ship); - if (ship.nav.status === 'DOCKED') return; - const response = await api.send<{nav: Nav}>({endpoint: `/my/ships/${ship.symbol}/dock`, method: 'POST'}); - if (response.error) { - switch(response.error.code) { - case 4214: // ship is in transit - const errorData = response.error.data as { secondsToArrival: number}; - await api.sleep(errorData.secondsToArrival * 1000); - return await dock(ship); - default: // yet unhandled error - api.debugLog(response); - throw response; - } +export class Ship { + cargo: Cargo; + cooldown: Cooldown; + // crew + // engine + // frame + fuel: Fuel; + // modules + // mounts + nav: Nav; + // reactor + registration: Registration; + symbol: string; + constructor(ship: Ship) { + this.cargo = ship.cargo; + this.cooldown = ship.cooldown; + this.fuel = ship.fuel; + this.nav = ship.nav; + this.registration = ship.registration; + this.symbol = ship.symbol; } - dbShips.setShipNav(ship.symbol, response.data.nav); -} - -export async function extract(ship: Ship): Promise<Cargo> { - ship = await getShip(ship); - if (await isFull(ship)) return ship.cargo; - // TODO move to a suitable asteroid? - // const asteroidFields = await systems.type({symbol: ship.nav.systemSymbol, type: 'ENGINEERED_ASTEROID'}); - // TODO if there are multiple fields, find the closest one? - //await navigate({symbol: ctx.symbol, waypoint: asteroidFields[0].symbol}); - await orbit(ship); - // TODO handle surveying? - const response = await api.send<{cooldown: Cooldown, cargo: Cargo}>({endpoint: `/my/ships/${ship.symbol}/extract`, method: 'POST'}); // TODO extraction and events api response fields cf https://spacetraders.stoplight.io/docs/spacetraders/b3931d097608d-extract-resources - if (response.error) { - switch(response.error.code) { - case 4000: // ship is on cooldown - const errorData = response.error.data as {cooldown: Cooldown}; - await api.sleep(errorData.cooldown.remainingSeconds * 1000); - return await extract(ship); - case 4228: // ship is full - return ship.cargo; - default: // yet unhandled error - api.debugLog(response); - throw response; + async dock(): Promise<void> { + if (this.nav.status === 'DOCKED') return; + const response = await send<{nav: Nav}>({endpoint: `/my/ships/${this.symbol}/dock`, method: 'POST'}); + if (response.error) { + switch(response.error.code) { + case 4214: + const sicite = response.error.data as ShipIsCurrentlyInTransitError; + await sleep(sicite.secondsToArrival * 1000); + return await this.dock(); + default: // yet unhandled error + debugLog(response); + throw response; + } } - } else { - dbShips.setShipCargo(ship.symbol, response.data.cargo); - await api.sleep(response.data.cooldown.remainingSeconds*1000); + this.nav = response.data.nav; } - return response.data.cargo -} - -export async function isFull(ship: Ship): Promise<boolean> { - ship = await getShip(ship); - return ship.cargo.units >= ship.cargo.capacity * 0.9; -} - -//function hasMount(shipSymbol, mountSymbol) { -// const ship = dbShips.getShip(shipSymbol); -// return ship.mounts.filter(s => s.symbol === mountSymbol).length > 0; -//} - -//export async function jump(ship: Ship): Ship { -// // TODO -// const response = await api.send({endpoint: `/my/ships/${ctx.ship}/jump`, method: 'POST', payload: { systemSymbol: ctx.system }}); -// await api.sleep(response.data.cooldown.remainingSeconds*1000); -// return response; -//} - -export async function navigate(ship: Ship, waypoint: string): Promise<void> { - ship = await getShip(ship); - if (ship.nav.waypointSymbol === waypoint) return; - await orbit(ship); - // TODO if we do not have enough fuel, make a stop to refuel along the way or drift to the destination - const response = await api.send<{fuel: Fuel, nav: Nav}>({endpoint: `/my/ships/${ship.symbol}/navigate`, method: 'POST', payload: { waypointSymbol: waypoint }}); // TODO events field - if (response.error) { - switch(response.error.code) { - case 4214: // ship is in transit - const errorData = response.error.data as { secondsToArrival: number}; - await api.sleep(errorData.secondsToArrival * 1000); - return await navigate(ship, waypoint); - default: // yet unhandled error - api.debugLog(response); - throw response; + async extract(): Promise<Cargo> { + if (this.isFull()) return this.cargo; + // TODO move to a suitable asteroid? + // const asteroidFields = await systems.type({symbol: this.nav.systemSymbol, type: 'ENGINEERED_ASTEROID'}); + // TODO if there are multiple fields, find the closest one? + //await navigate({symbol: ctx.symbol, waypoint: asteroidFields[0].symbol}); + await this.orbit(); + // TODO handle surveying? + const response = await send<{cooldown: Cooldown, cargo: Cargo}>({endpoint: `/my/ships/${this.symbol}/extract`, method: 'POST'}); // TODO extraction and events api response fields cf https://spacetraders.stoplight.io/docs/spacetraders/b3931d097608d-extract-resources + if (response.error) { + switch(response.error.code) { + case 4000: + const sisoce = response.error.data as ShipIsStillOnCooldownError; + await sleep(sisoce.cooldown.remainingSeconds * 1000); + return await this.extract(); + case 4228: // ship is full + return this.cargo; + default: // yet unhandled error + debugLog(response); + throw response; + } } + this.cargo = response.data.cargo; + await sleep(response.data.cooldown.remainingSeconds*1000); + return this.cargo; } - dbShips.setShipFuel(ship.symbol, response.data.fuel); - dbShips.setShipNav(ship.symbol, response.data.nav); - const delay = new Date(response.data.nav.route.arrival).getTime() - new Date().getTime() ; - await api.sleep(delay); - response.data.nav.status = 'IN_ORBIT'; // we arrive in orbit - dbShips.setShipNav(ship.symbol, response.data.nav); - // TODO only refuel at the start of a journey, if we do not have enough OR if the destination does not sell fuel? - await refuel(ship); -} - -export async function negotiate(ship: Ship): Promise<Contract> { - ship = await getShip(ship); - const response = await api.send<{contract: Contract}>({endpoint: `/my/ships/${ship.symbol}/negotiate/contract`, method: 'POST'}); - if (response.error) { - switch(response.error.code) { - case 4214: // ship is in transit - const errorData = response.error.data as { secondsToArrival: number}; - await api.sleep(errorData.secondsToArrival * 1000); - return await negotiate(ship); - default: // yet unhandled error - api.debugLog(response); - throw response; + isFull(): boolean { + return this.cargo.units >= this.cargo.capacity * 0.9; + } + async navigate(waypointSymbol: string): Promise<void> { + if (this.nav.waypointSymbol === waypointSymbol) return; + const d = + // TODO compute fuel consumption and refuel if we do not have enough OR if the destination does not sell fuel? + await this.refuel(); + await this.orbit(); + // TODO if we do not have enough fuel, make a stop to refuel along the way or drift to the destination + const response = await send<{fuel: Fuel, nav: Nav}>({endpoint: `/my/ships/${this.symbol}/navigate`, method: 'POST', payload: { waypointSymbol: waypointSymbol }}); // TODO events field + if (response.error) { + switch(response.error.code) { + case 4203: // not enough fuel + const srmffne = response.error.data as ShipRequiresMoreFuelForNavigationError; + // TODO test if it exceeds our maximum + // find an intermediate stop to refuel if that is the case + debugLog(response); + throw response; + //await refuel(ship); + //return await navigate(ship, waypoint); + case 4214: + const sicite = response.error.data as ShipIsCurrentlyInTransitError; + await sleep(sicite.secondsToArrival * 1000); + return await this.navigate(waypointSymbol); + default: // yet unhandled error + debugLog(response); + throw response; + } } + this.fuel = response.data.fuel; + this.nav = response.data.nav; + const delay = new Date(this.nav.route.arrival).getTime() - new Date().getTime() ; + await sleep(delay); + this.nav.status = 'IN_ORBIT'; // we arrive in orbit } - return response.data.contract; -} - -export async function orbit(ship: Ship): Promise<void> { - ship = await getShip(ship); - if (ship.nav.status === 'IN_ORBIT') return; - const response = await api.send<{nav: Nav}>({endpoint: `/my/ships/${ship.symbol}/orbit`, method: 'POST'}); - if (response.error) { - switch(response.error.code) { - case 4214: // ship is in transit - const errorData = response.error.data as { secondsToArrival: number}; - await api.sleep(errorData.secondsToArrival * 1000); - return await orbit(ship); - default: // yet unhandled error - api.debugLog(response); - throw response; + async negotiate(): Promise<Contract> { + const response = await send<{contract: Contract}>({endpoint: `/my/ships/${this.symbol}/negotiate/contract`, method: 'POST'}); + if (response.error) { + switch(response.error.code) { + case 4214: + const sicite = response.error.data as ShipIsCurrentlyInTransitError; + await sleep(sicite.secondsToArrival * 1000); + return await this.negotiate(); + default: // yet unhandled error + debugLog(response); + throw response; + } } + return response.data.contract; } - dbShips.setShipNav(ship.symbol, response.data.nav); -} - -//export async function purchase(ctx) { -// const response = await api.send({endpoint: '/my/ships', method: 'POST', payload: { -// shipType: ctx.shipType, -// waypointSymbol: ctx.waypoint, -// }}); -// if (response.error !== undefined) { -// throw response; -// } -// dbShips.setShip(response.data.ship); -// return response.data; -//} - -export async function refuel(ship: Ship): Promise<void> { - ship = await getShip(ship); - if (ship.fuel.current >= ship.fuel.capacity * 0.9) return; - // TODO check if our current waypoint has a marketplace (and sells fuel)? - await dock(ship); - const response = await api.send<{agent: Agent, fuel: Fuel}>({endpoint: `/my/ships/${ship.symbol}/refuel`, method: 'POST'}); // TODO transaction field - if (response.error) { - api.debugLog(response); - throw response; + async orbit(): Promise<void> { + if (this.nav.status === 'IN_ORBIT') return; + const response = await send<{nav: Nav}>({endpoint: `/my/ships/${this.symbol}/orbit`, method: 'POST'}); + if (response.error) { + switch(response.error.code) { + case 4214: + const sicite = response.error.data as ShipIsCurrentlyInTransitError; + await sleep(sicite.secondsToArrival * 1000); + return await this.orbit(); + default: // yet unhandled error + debugLog(response); + throw response; + } + } + this.nav = response.data.nav; } - dbShips.setShipFuel(ship.symbol, response.data.fuel); - dbAgents.setAgent(response.data.agent); -} - -export async function sell(ship: Ship, tradeSymbol: string): Promise<Cargo> { - ship = await getShip(ship); - // TODO check if our current waypoint has a marketplace and buys tradeSymbol? - await dock(ship); - let units = 0; - ship.cargo.inventory.forEach(i => {if (i.symbol === tradeSymbol) units = i.units; }); - const response = await api.send<{agent: Agent, cargo: Cargo}>({endpoint: `/my/ships/${ship.symbol}/sell`, method: 'POST', payload: { symbol: tradeSymbol, units: units }}); // TODO transaction field - if (response.error) { - api.debugLog(response); - throw response; + async purchase(tradeSymbol: string, units: number): Promise<void> { + if (units <= 0) return; + await this.dock(); + // TODO take into account the tradevolume, we might need to buy in multiple steps + const response = await send<{agent: Agent, cargo: Cargo}>({endpoint: `/my/ships/${this.symbol}/purchase`, method: 'POST', payload: { symbol: tradeSymbol, units: units }}); // TODO transaction field + if (response.error) { + switch(response.error.code) { + case 4604: // units per transaction limit exceeded + const mtve = response.error.data as MarketTradeVolumeError; + await this.purchase(tradeSymbol, mtve.tradeVolume); + return await this.purchase(tradeSymbol, units - mtve.tradeVolume); + default: + debugLog(response); + throw response; + } + } + this.cargo = response.data.cargo; + dbAgents.setAgent(response.data.agent); } - dbShips.setShipCargo(ship.symbol, response.data.cargo); - dbAgents.setAgent(response.data.agent); - return response.data.cargo; -} - -export async function getShips(): Promise<Array<Ship>> { - const response = await api.send<Array<Ship>>({endpoint: `/my/ships`, page: 1}); - if (response.error) { - api.debugLog(response); - throw response; + async refuel(): Promise<void> { + // TODO check if our current waypoint has a marketplace (and sells fuel)? + await this.dock(); + const response = await send<{agent: Agent, fuel: Fuel}>({endpoint: `/my/ships/${this.symbol}/refuel`, method: 'POST'}); // TODO transaction field + if (response.error) { + debugLog(response); + throw response; + } + this.fuel = response.data.fuel; + dbAgents.setAgent(response.data.agent); } - response.data.forEach(ship => dbShips.setShip(ship)); - return response.data; -} - -export async function getShip(ship: Ship): Promise<Ship> { - try { - return dbShips.getShip(ship.symbol); - } catch {} - const response = await api.send<Ship>({endpoint: `/my/ships/${ship.symbol}`}); - if (response.error) { - api.debugLog(response); - throw response; + async sell(tradeSymbol: string): Promise<Cargo> { + // TODO check if our current waypoint has a marketplace and buys tradeSymbol? + await this.dock(); + let units = 0; + this.cargo.inventory.forEach(i => {if (i.symbol === tradeSymbol) units = i.units; }); + const response = await send<{agent: Agent, cargo: Cargo}>({endpoint: `/my/ships/${this.symbol}/sell`, method: 'POST', payload: { symbol: tradeSymbol, units: units }}); // TODO transaction field + if (response.error) { + debugLog(response); + throw response; + } + this.cargo = response.data.cargo; + dbAgents.setAgent(response.data.agent); + return this.cargo; } - dbShips.setShip(response.data); - return response.data; } - -//export async function survey(ctx) { -// if (!hasMount(ctx.symbol, 'MOUNT_SURVEYOR_I')) { // we check if a surveyor is mounted on the ship -// return null; -// } -// const ship = dbShips.getShip(ctx.symbol); -// const asteroidFields = await systems.type({symbol: ship.nav.systemSymbol, type: 'ASTEROID_FIELD'}); -// // TODO if there are multiple fields, find the closest one? -// await navigate({symbol: ctx.symbol, waypoint: asteroidFields[0].symbol}); -// await orbit(ctx); -// const response = await api.send({endpoint: `/my/ships/${ctx.symbol}/survey`, method: 'POST'}); -// api.debugLog(response); -// if (response.error !== undefined) { -// switch(response.error.code) { -// case 4000: // ship is on cooldown -// await api.sleep(response.error.data.cooldown.remainingSeconds * 1000); -// return await survey(ctx); -// default: // yet unhandled error -// throw response; -// } -// } -// dbSurveys.set(response.data.surveys[0]); -// await api.sleep(response.data.cooldown.remainingSeconds*1000); -// return response; -//} diff --git a/nodejs/lib/systems.ts b/nodejs/lib/systems.ts index dc938bb..97aa6e3 100644 --- a/nodejs/lib/systems.ts +++ b/nodejs/lib/systems.ts @@ -1,18 +1,24 @@ -import * as api from './api.ts'; +import { + debugLog, + send, + sendPaginated, +} from './api.ts'; import * as dbMarkets from '../database/markets.ts'; -import * as dbShips from '../database/ships.ts'; import * as dbSystems from '../database/systems.ts'; -import { Market } from '../model/market.ts' -import { System, Waypoint } from '../model/system.ts' -import * as utils from './utils.ts'; +import { + Market, + System, + Waypoint +} from './types.ts' +import { systemFromWaypoint } from './utils.ts'; export async function market(waypointSymbol: string): Promise<Market> { const data = dbMarkets.getMarketAtWaypoint(waypointSymbol); if (data) { return data; } - const systemSymbol = utils.systemFromWaypoint(waypointSymbol); - let response = await api.send<Market>({endpoint: `/systems/${systemSymbol}/waypoints/${waypointSymbol}/market`}); + const systemSymbol = systemFromWaypoint(waypointSymbol); + let response = await send<Market>({endpoint: `/systems/${systemSymbol}/waypoints/${waypointSymbol}/market`}); if (response.error) { - api.debugLog(response); + debugLog(response); throw response; } dbMarkets.setMarket(response.data); @@ -21,16 +27,16 @@ export async function market(waypointSymbol: string): Promise<Market> { //export async function shipyard(waypoint: string): Promise<unknown> { // // TODO database caching -// const systemSymbol = utils.systemFromWaypoint(waypoint); -// return await api.send({endpoint: `/systems/${systemSymbol}/waypoints/${waypoint}/shipyard`}); +// const systemSymbol = systemFromWaypoint(waypoint); +// return await send({endpoint: `/systems/${systemSymbol}/waypoints/${waypoint}/shipyard`}); //} export async function system(symbol: string): Promise<System> { let data = dbSystems.getSystem(symbol); if (data) { return data; } - const response = await api.send<System>({endpoint: `/systems/${symbol}`}); + const response = await send<System>({endpoint: `/systems/${symbol}`}); if (response.error) { - api.debugLog(response); + debugLog(response); throw response; } dbSystems.setSystem(response.data); @@ -54,7 +60,7 @@ export async function waypoints(systemSymbol: string): Promise<Array<Waypoint>> const updated = dbSystems.getSystemUpdated(systemSymbol); // TODO handle uncharted systems if (updated) return s.waypoints; - const waypoints = await api.sendPaginated<Waypoint>({endpoint: `/systems/${systemSymbol}/waypoints`}); + const waypoints = await sendPaginated<Waypoint>({endpoint: `/systems/${systemSymbol}/waypoints`}); dbSystems.setSystemWaypoints(systemSymbol, waypoints); return waypoints; } diff --git a/nodejs/lib/types.ts b/nodejs/lib/types.ts new file mode 100644 index 0000000..a8e748c --- /dev/null +++ b/nodejs/lib/types.ts @@ -0,0 +1,145 @@ +export type Agent = { + accountId: string; + credits: number; + headquarters: string; + shipCount: number; + startingFaction: string; + symbol: string; +}; + +export type CommonThing = { + description: string; + name: string; + symbol: string; +}; + +export type Cargo = { + capacity: number; + units: number; + inventory: Array<Inventory>; +}; + +// Custom type, not from space traders api +export type CargoManifest = { + [key: string]: number; +}; + +export type Chart = { + waypointSymbol: string; + submittedBy: string; + submittedOn: Date; +}; + +export type Contract = { + id: string; + factionSymbol: string; + type: string; + terms: { + deadline: Date; + payment: { + onAccepted: number; + onFulfilled: number; + }, + deliver: Array<{ + tradeSymbol: string; + destinationSymbol: string; + unitsRequired: number; + unitsFulfilled: number; + }>; + }; + accepted: boolean; + fulfilled: boolean; + expiration: Date; + deadlineToAccept: Date; +}; + +export type Cooldown = { + shipSymbol: string; + totalSeconds: number; + remainingSeconds: number; +}; + +export type Consummed = { + amount: number; + timestamp: Date; +}; + +export type Fuel = { + capacity: number; + consummed: Consummed; + current: number; +}; + +export type Inventory = CommonThing & { + units: number; +}; + +export type Market = { + symbol: string; + exchange: Array<CommonThing>; + exports: Array<CommonThing>; + imports: Array<CommonThing>; + //transactions: Array<Transaction>; + tradeGoods: Array<TradeGood>; +}; + +export type Nav = { + flightMode: string; + route: Route; + status: string; + systemSymbol: string; + waypointSymbol: string; +}; + +export type Registration = { + factionSymbol: string; + name: string; + role: string; +}; + +export type Route = { + arrival: Date; + departureTime: Date; + destination: RouteEndpoint; + origin: RouteEndpoint; +}; + +export type RouteEndpoint = { + type: string; + symbol: string; + systemSymbol: string; + x: number; + y: number; +}; + +export type System = { + symbol: string; + sectorSymbol: string; + type: string; + x: number; + y: number; + waypoints: Array<Waypoint>; +}; + +export type TradeGood = CommonThing & { + activity: string; + purchasePrice: number; + sellPrice: number; + supply: string; + tradeVolume: number; + type: string; +}; + +export type Waypoint = { + chart: Chart; + factions: Array<{symbol: string;}>; + isUnderConstruction: boolean; + modifiers: Array<CommonThing>; + orbitals: Array<{symbol: string;}>; + orbits: string; + symbol: string; + traits: Array<CommonThing>; + type: string; + x: number; + y: number; +}; diff --git a/nodejs/lib/utils.ts b/nodejs/lib/utils.ts index c5093a6..39378e9 100644 --- a/nodejs/lib/utils.ts +++ b/nodejs/lib/utils.ts @@ -1,4 +1,4 @@ -import { Cargo, CargoManifest } from '../model/cargo.ts'; +import { Cargo, CargoManifest } from './types.ts'; export type CategorizedCargo = { wanted: CargoManifest; |