feat(server/vehicle): vehicle creation/spawn tweaks and lib bindings

lib/server/vehicle.ts

@@ -1,4 +1,5 @@
 import type { OxVehicle } from 'server/vehicle/class';
+import type { VehicleProperties } from '@overextended/ox_lib';
 
 class VehicleInterface {
   constructor(
@@ -24,22 +25,28 @@ class VehicleInterface {
     this.owner = owner;
     this.group = group;
   }
+
+  getCoords() {
+    return GetEntityCoords(this.entity);
+  }
+
+  getState() {
+    return Entity(this.entity).state;
+  }
 }
 
 Object.keys(exports.ox_core.GetVehicleCalls()).forEach((method: string) => {
   (VehicleInterface.prototype as any)[method] = function (...args: any[]) {
-    return exports.ox_core.CallVehicle(this.source, method, ...args);
+    return exports.ox_core.CallVehicle(this.entity, method, ...args);
   };
 });
 
 VehicleInterface.prototype.toString = function () {
   return JSON.stringify(this, null, 2);
 };
 
-export function GetVehicle(entityId: number): OxVehicle | void {
-  const vehicle = exports.ox_core.GetVehicle(entityId);
-
-  if (!vehicle) return console.error(`cannot create VehicleInterface<${entityId}> (invalid id)`);
+function CreateVehicleInstance(vehicle?: InstanceType<typeof OxVehicle>) {
+  if (!vehicle) return;
 
   return new VehicleInterface(
     vehicle.entity,
@@ -52,9 +59,39 @@ export function GetVehicle(entityId: number): OxVehicle | void {
     vehicle.vin,
     vehicle.owner,
     vehicle.group
-  ) as OxVehicle;
+  ) as VehicleInterface & OxVehicle;
+}
+
+export function GetVehicle(entityId: number) {
+  return CreateVehicleInstance(exports.ox_core.GetVehicle(entityId));
 }
 
 export function GetVehicleFromNetId(netId: number) {
-  return GetVehicle(NetworkGetEntityFromNetworkId(netId));
+  return CreateVehicleInstance(exports.ox_core.GetVehicleFromNetId(netId));
+}
+
+export function GetVehicleFromVin(vin: string) {
+  return CreateVehicleInstance(exports.ox_core.GetVehicleFromVin(vin));
+}
+
+export async function CreateVehicle(
+  data: {
+    model: string;
+    owner?: number;
+    group?: string;
+    stored?: number;
+    properties?: VehicleProperties;
+  },
+  coords?: number | number[] | { x: number; y: number; z: number },
+  heading?: number
+) {
+  return CreateVehicleInstance(await exports.ox_core.CreateVehicle(data, coords, heading));
+}
+
+export async function SpawnVehicle(
+  dbId: number,
+  coords: number | number[] | { x: number; y: number; z: number },
+  heading?: number
+) {
+  return CreateVehicleInstance(await exports.ox_core.SpawnVehicle(dbId, coords, heading));
 }

server/vehicle/class.ts

@@ -22,6 +22,7 @@ export class OxVehicle extends ClassInterface {
   protected static keys: Dict<Dict<OxVehicle>> = {
     id: {},
     netId: {},
+    vin: {},
   };
 
   /** Get an instance of OxVehicle with the matching entityId. */
@@ -39,6 +40,11 @@ export class OxVehicle extends ClassInterface {
     return this.keys.netId[id];
   }
 
+  /** Get an instance of OxVehicle with the matching vin. */
+  static getFromVin(vin: string) {
+    return this.keys.vin[vin];
+  }
+
   /** Gets all instances of OxVehicle. */
   static getAll(): Dict<OxVehicle> {
     return this.members;
@@ -105,7 +111,7 @@ export class OxVehicle extends ClassInterface {
     vin?: string,
     owner?: number,
     group?: string,
-    metadata?: Dict<any>,
+    metadata?: Dict<any>
   ) {
     super();
     this.entity = entity;
@@ -195,4 +201,6 @@ export class OxVehicle extends ClassInterface {
 
 OxVehicle.init();
 
-exports('SaveAllVehicles', OxVehicle.saveAll);
+exports('SaveAllVehicles', (arg: any) => OxVehicle.saveAll(arg));
+exports('GetVehicleFromNetId', (arg: any) => OxVehicle.getFromNetId(arg));
+exports('GetVehicleFromVin', (arg: any) => OxVehicle.getFromVin(arg));

server/vehicle/commands.ts

@@ -27,13 +27,13 @@ addCommand<{ model: string; owner?: number }>(
       owner: player?.charId || undefined,
     };
 
-    const entity = await CreateVehicle(data, GetEntityCoords(ped), GetEntityHeading(ped));
+    const vehicle = await CreateVehicle(data, GetEntityCoords(ped), GetEntityHeading(ped));
 
-    if (!entity) return;
+    if (!vehicle) return;
 
     DeleteCurrentVehicle(ped);
     await sleep(200);
-    SetPedIntoVehicle(ped, entity, -1);
+    SetPedIntoVehicle(ped, vehicle.entity, -1);
   },
   {
     help: `Spawn a vehicle with the given model.`,

server/vehicle/db.ts

@@ -1,5 +1,8 @@
+import type { Dict } from 'types';
 import { db } from '../db';
 
+export type VehicleRow = { id: number; owner?: number; group?: string; plate: string; vin: string; model: string; data: Dict<any> }
+
 setImmediate(() => db.query('UPDATE vehicles SET `stored` = ? WHERE `stored` IS NULL', ['impound']));
 
 export async function IsPlateAvailable(plate: string) {
@@ -11,9 +14,8 @@ export async function IsVinAvailable(plate: string) {
 }
 
 export function GetStoredVehicleFromId(id: number) {
-  return db.row<
-    Partial<{ id: number; owner: number; group: string; plate: string; vin: string; model: string; data: string }>
-  >('SELECT id, owner, `group`, plate, vin, model, data FROM vehicles WHERE id = ? AND `stored` IS NOT NULL', [id]);
+  return db.row<VehicleRow>
+    ('SELECT id, owner, `group`, plate, vin, model, data FROM vehicles WHERE id = ? AND `stored` IS NOT NULL', [id]);
 }
 
 export async function SetVehicleColumn(id: number | void, column: string, value: any) {

server/vehicle/index.ts

@@ -1,16 +1,24 @@
 import { OxVehicle } from './class';
-import { CreateNewVehicle, GetStoredVehicleFromId, IsPlateAvailable } from './db';
+import { CreateNewVehicle, GetStoredVehicleFromId, IsPlateAvailable, VehicleRow } from './db';
 import { GetVehicleData } from '../../common/vehicles';
 import { DEBUG } from '../../common/config';
 
 import './class';
 import './commands';
-import { Dict } from 'types';
+import type { Dict } from 'types';
 
 if (DEBUG) import('./parser');
 
 export async function CreateVehicle(
-  data: string | Dict<any>,
+  data:
+    | string
+    | (Partial<VehicleRow> & {
+        model: string;
+        owner?: number;
+        group?: string;
+        stored?: string;
+        properties?: Dict<any>;
+      }),
   coords?: number | number[] | { x: number; y: number; z: number },
   heading?: number
 ) {
@@ -28,7 +36,7 @@ export async function CreateVehicle(
 
     if (vehicle) {
       if (DoesEntityExist(vehicle.entity)) {
-        return vehicle.entity;
+        return vehicle;
       }
 
       vehicle.despawn(true);
@@ -66,21 +74,21 @@ export async function CreateVehicle(
     : 0;
 
   if (!coords || !DoesEntityExist(entity)) return;
-  if (!data.vin && (data.owner || data.owner)) data.vin = await OxVehicle.generateVin(data as any);
-  if (data.vin && !data.owner && !data.owner) delete data.vin;
+  if (!data.vin && (data.owner || data.group)) data.vin = await OxVehicle.generateVin(data as any);
+  if (data.vin && !data.owner && !data.group) delete data.vin;
 
   data.plate = data.plate && (await IsPlateAvailable(data.plate)) ? data.plate : await OxVehicle.generatePlate();
 
   if (!data.id && data.vin) {
     data.id = await CreateNewVehicle(
       data.plate,
       data.vin,
-      data.owner,
-      data.group,
+      data.owner || null,
+      data.group || null,
       data.model,
       vehicleData.class,
       data.data || {},
-      data.stored
+      data.stored || null
     );
   }
 
@@ -92,6 +100,7 @@ export async function CreateVehicle(
     data.plate,
     data.model,
     vehicleData.make,
+    data.stored || null,
     data.id,
     data.vin,
     data.owner,
@@ -101,7 +110,7 @@ export async function CreateVehicle(
 
   if (vehicle.id) vehicle.setStored(null, false);
 
-  return vehicle.entity;
+  return vehicle;
 }
 
 export async function SpawnVehicle(id: number, coords: number | number[], heading?: number) {