@softruck/api-contracts 0.1.1-beta.3

package/dist/core/index.js

@@ -0,0 +1,4 @@
+export * from './client.js';
+export * from './query-builder.js';
+export * from './schemas.js';
+export * from './types.js';

package/dist/core/query-builder.d.ts

@@ -0,0 +1,34 @@
+export declare const FILTER_OPERATORS: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "btw", "nbtw", "ilk", "ew", "sw", "in", "nin", "is"];
+export type FilterOperator = typeof FILTER_OPERATORS[number];
+export declare const FILTERS_OPERATORS: {
+    readonly string: readonly ["eq", "neq", "ilk", "ew", "sw"];
+    readonly number: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "btw", "nbtw"];
+    readonly boolean: readonly ["eq", "neq"];
+    readonly date: readonly ["gt", "gte", "lt", "lte", "btw", "nbtw"];
+    readonly shortdate: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "btw", "nbtw"];
+    readonly enum: readonly ["in", "nin"];
+};
+export interface FilterValue {
+    operator: FilterOperator;
+    value: string | number | boolean;
+}
+export interface SortParam {
+    prop: string;
+    order: 'ASC' | 'DESC';
+}
+export interface QueryParams {
+    count?: boolean | 'only';
+    page?: number;
+    limit?: number;
+    search?: string;
+    attributes?: string[];
+    includes?: Record<string, string[]>;
+    filters?: Record<string, FilterValue | FilterValue[]>;
+    sort?: SortParam;
+    any?: Record<string, {
+        value: string | number;
+    }>;
+}
+export declare function buildQuery(params: QueryParams): string;
+export declare function withQuery(url: string, params: QueryParams): string;
+export declare function mergeQuery(base: QueryParams, overrides: Partial<QueryParams>): QueryParams;

package/dist/core/query-builder.js

@@ -0,0 +1,86 @@
+export const FILTER_OPERATORS = [
+    'eq', 'neq', 'gt', 'gte', 'lt', 'lte',
+    'btw', 'nbtw', 'ilk', 'ew', 'sw',
+    'in', 'nin', 'is',
+];
+export const FILTERS_OPERATORS = {
+    string: ['eq', 'neq', 'ilk', 'ew', 'sw'],
+    number: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'btw', 'nbtw'],
+    boolean: ['eq', 'neq'],
+    date: ['gt', 'gte', 'lt', 'lte', 'btw', 'nbtw'],
+    shortdate: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'btw', 'nbtw'],
+    enum: ['in', 'nin'],
+};
+function sanitizeSearch(value) {
+    return value
+        .replace(/&/g, '%26')
+        .replace(/\?/g, '')
+        .replace(/'/g, '')
+        .replace(/--/g, '')
+        .replace(/=/g, '')
+        .replace(/\/\//g, '');
+}
+function buildParts(params) {
+    const parts = [];
+    if (params.count !== undefined) {
+        parts.push(`count=${params.count}`);
+    }
+    if (params.page !== undefined) {
+        parts.push(`page=${params.page}`);
+    }
+    if (params.limit !== undefined) {
+        parts.push(`limit=${params.limit}`);
+    }
+    if (params.search) {
+        parts.push(`search=${sanitizeSearch(params.search)}`);
+    }
+    if (params.attributes?.length) {
+        parts.push(`attributes=${params.attributes.join(',')}`);
+    }
+    if (params.includes) {
+        for (const [key, fields] of Object.entries(params.includes)) {
+            parts.push(`includes[${key}]=${fields.join(',')}`);
+        }
+    }
+    if (params.filters) {
+        for (const [key, val] of Object.entries(params.filters)) {
+            if (Array.isArray(val)) {
+                val.forEach((v, i) => parts.push(`filters[${key}][${v.operator}][${i}]=${v.value}`));
+            }
+            else {
+                parts.push(`filters[${key}][${val.operator}]=${val.value}`);
+            }
+        }
+    }
+    if (params.sort) {
+        parts.push(`sort[${params.sort.prop}]=${params.sort.order === 'ASC' ? '1' : '-1'}`);
+    }
+    if (params.any) {
+        for (const [key, { value }] of Object.entries(params.any)) {
+            parts.push(`${key}=${value}`);
+        }
+    }
+    return parts;
+}
+function toBase64(str) {
+    return btoa(unescape(encodeURIComponent(str)));
+}
+export function buildQuery(params) {
+    return toBase64(buildParts(params).join('&'));
+}
+export function withQuery(url, params) {
+    const parts = buildParts(params);
+    if (parts.length === 0) {
+        return url;
+    }
+    return `${url}?q=${encodeURIComponent(toBase64(parts.join('&')))}`;
+}
+export function mergeQuery(base, overrides) {
+    const result = { ...base };
+    for (const [k, v] of Object.entries(overrides)) {
+        if (v !== undefined) {
+            result[k] = v;
+        }
+    }
+    return result;
+}

package/dist/core/schemas.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export declare const varChar: (length?: number) => z.ZodString;
+export declare const varCharOptional: (length?: number) => z.ZodOptional<z.ZodString>;
+export declare const nullableVarCharOptional: (length?: number) => z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+export declare const FilterValueSchema: z.ZodObject<{
+    operator: z.ZodEnum<{
+        in: "in";
+        eq: "eq";
+        neq: "neq";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        btw: "btw";
+        nbtw: "nbtw";
+        ilk: "ilk";
+        ew: "ew";
+        sw: "sw";
+        nin: "nin";
+        is: "is";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, z.core.$strict>;
+export declare function makeQueryParamsSchema<TKey extends string>(attributeKeySchema: z.ZodType<TKey>): z.ZodObject<{
+    count: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"only">]>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    search: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodType<TKey, unknown, z.core.$ZodTypeInternals<TKey, unknown>>, z.ZodLiteral<"*">]>>>;
+    filters: z.ZodOptional<z.ZodRecord<z.ZodType<TKey, unknown, z.core.$ZodTypeInternals<TKey, unknown>> & z.core.$partial, z.ZodUnion<readonly [z.ZodObject<{
+        operator: z.ZodEnum<{
+            in: "in";
+            eq: "eq";
+            neq: "neq";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            btw: "btw";
+            nbtw: "nbtw";
+            ilk: "ilk";
+            ew: "ew";
+            sw: "sw";
+            nin: "nin";
+            is: "is";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            in: "in";
+            eq: "eq";
+            neq: "neq";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            btw: "btw";
+            nbtw: "nbtw";
+            ilk: "ilk";
+            ew: "ew";
+            sw: "sw";
+            nin: "nin";
+            is: "is";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>>]>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        prop: z.ZodType<TKey, unknown, z.core.$ZodTypeInternals<TKey, unknown>>;
+        order: z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const EnterpriseRelAttrSchema: z.ZodObject<{
+    name: z.ZodNullable<z.ZodString>;
+    cnpj: z.ZodNullable<z.ZodString>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type EnterpriseRelAttr = z.infer<typeof EnterpriseRelAttrSchema>;

package/dist/core/schemas.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { FILTER_OPERATORS } from './query-builder.js';
+// Mirrors the backend's `varChar` Joi helper (`Joi.string().max(length)`): Joi's
+// string() rejects '' by default, so `.min(1)` is required to match that behavior —
+// plain `z.string()` would silently accept empty strings Joi would reject.
+export const varChar = (length = 255) => z.string().min(1).max(length);
+export const varCharOptional = (length = 255) => varChar(length).optional();
+export const nullableVarCharOptional = (length = 255) => varCharOptional(length).nullable().optional();
+export const FilterValueSchema = z.object({
+    operator: z.enum(FILTER_OPERATORS),
+    value: z.union([z.string(), z.number(), z.boolean()]),
+}).strict();
+// Builds a strict QueryParams schema for a resource, restricting `attributes`,
+// `filters` and `sort.prop` to that resource's own attribute keys.
+export function makeQueryParamsSchema(attributeKeySchema) {
+    const attributeSelectionSchema = z.union([attributeKeySchema, z.literal('*')]);
+    return z.object({
+        count: z.union([z.boolean(), z.literal('only')]).optional(),
+        page: z.number().optional(),
+        limit: z.number().optional(),
+        search: z.string().optional(),
+        attributes: z.array(attributeSelectionSchema).optional(),
+        filters: z.partialRecord(attributeKeySchema, z.union([FilterValueSchema, z.array(FilterValueSchema)])).optional(),
+        sort: z.object({ prop: attributeKeySchema, order: z.enum(['ASC', 'DESC']) }).strict().optional(),
+    }).strict();
+}
+export const EnterpriseRelAttrSchema = z.object({
+    name: z.string().nullable(),
+    cnpj: z.string().nullable(),
+    email: z.string().nullable().optional(),
+});

package/dist/core/types.d.ts

@@ -0,0 +1,119 @@
+export interface ListResponse<T> {
+    data: T[];
+    count?: number;
+}
+export interface PagedResponse<T> {
+    data: T[];
+    count: number;
+}
+export interface Timestamped {
+    created_at: string | null;
+    updated_at: string | null;
+}
+export interface Deactivatable extends Timestamped {
+    deactivated_at: string | null;
+}
+export type { EnterpriseRelAttr } from './schemas';
+export interface DeviceRelAttr {
+    name: string | null;
+    imei: string | null;
+    code: string | null;
+}
+export interface ChipRelAttr {
+    serial: string | null;
+    number: string | null;
+    imsi?: string | null;
+    service_provider: string | null;
+    carrier: string | null;
+}
+export interface VehicleRelAttr {
+    plate: string | null;
+    vin: string | null;
+    label: string | null;
+    type_name: string | null;
+    brand_name?: string | null;
+}
+export interface UserRelAttr {
+    name: string | null;
+    username?: string | null;
+    email: string | null;
+    phone1: string | null;
+    phone2?: string | null;
+    deleted_at?: string | null;
+}
+export interface TypeRelAttr {
+    name: string | null;
+}
+export interface SectionRelAttr {
+    name: string | null;
+}
+export interface CompletionRelAttr {
+    completed_at: string | null;
+}
+export interface AssigneeRelAttr {
+    name: string | null;
+    email: string | null;
+    phone1: string | null;
+    phone2: string | null;
+}
+export interface LastGpsAttr {
+    last_gps_time: string | null;
+    last_connection_time: string | null;
+    lat?: string | null;
+    lng?: string | null;
+}
+export interface Tag {
+    id: string;
+    attributes: {
+        name: string;
+        color: string | null;
+    };
+}
+export interface Address {
+    id: string;
+    attributes: {
+        formatted_address: string | null;
+        type?: string | null;
+    };
+}
+export interface Document {
+    id: string;
+    attributes: {
+        name: string | null;
+        key_name: string | null;
+        file_size: number | null;
+        mime: string | null;
+        created_at: string | null;
+    };
+}
+export interface CustomField {
+    id: string;
+    attributes: {
+        name: string | null;
+        field_format: string | null;
+        value: string | null;
+        is_required: boolean | null;
+    };
+}
+export interface TaskBaseAttributes extends Timestamped {
+    token: string | null;
+    status: string | null;
+    priority: string | null;
+    description: string | null;
+    notes: string | null;
+}
+export interface TaskEntry {
+    id: string;
+    attributes: {
+        category: string | null;
+        description: string | null;
+        amount: number | null;
+        unit_price: number | null;
+        total_price: number | null;
+    };
+    relationships: {
+        assignee: {
+            attributes: Pick<AssigneeRelAttr, 'name'>;
+        } | null;
+    };
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+// ─── Base response shapes ──────────────────────────────────────────────────
+export {};

package/dist/devices/activations/api.d.ts

@@ -0,0 +1,20 @@
+import type { ApiClientLike } from '../../core/client';
+import type { QueryParams } from '../../core/query-builder';
+import type { Activation, ActPanelRow, DeactPanelRow } from './types';
+export declare function createActivationsApi(client: ApiClientLike): {
+    panelAct: (params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: ActPanelRow[];
+    }>;
+    panelDeact: (params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: DeactPanelRow[];
+    }>;
+    endpoint: string;
+    list: <R = Activation>(params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<import("../..").ListResponse<R>>;
+    get: <R = Activation>(id: string, params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: R;
+    }>;
+    create: (payload: unknown) => Promise<undefined>;
+    update: (id: string, payload: unknown) => Promise<undefined>;
+    remove: (id: string) => Promise<undefined>;
+    removeMany: (payload: unknown, signal?: AbortSignal) => Promise<undefined>;
+};

package/dist/devices/activations/api.js

@@ -0,0 +1,9 @@
+import { createResourceApi } from '../../core/client.js';
+import { withQuery } from '../../core/query-builder.js';
+export function createActivationsApi(client) {
+    return {
+        ...createResourceApi(client, '/v5/devices/activation-history'),
+        panelAct: (params = {}, signal) => client.get(withQuery('/v5/devices/activation-history', params), { signal }).then(r => r.data),
+        panelDeact: (params = {}, signal) => client.get(withQuery('/v5/devices/activation-history', params), { signal }).then(r => r.data),
+    };
+}

package/dist/devices/activations/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './schemas';
+export * from './types';

package/dist/devices/activations/index.js

@@ -0,0 +1,3 @@
+export * from './api.js';
+export * from './schemas.js';
+export * from './types.js';

package/dist/devices/activations/schemas.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const ActivationSchema: z.ZodObject<{
+    id: z.ZodString;
+    attributes: z.ZodObject<{
+        activated_at: z.ZodNullable<z.ZodString>;
+        deactivated_at: z.ZodNullable<z.ZodString>;
+        created_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    relationships: z.ZodObject<{
+        device: z.ZodNullable<z.ZodObject<{
+            attributes: z.ZodObject<{
+                name: z.ZodNullable<z.ZodString>;
+                imei: z.ZodNullable<z.ZodString>;
+                code: z.ZodNullable<z.ZodString>;
+                active: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        activator: z.ZodNullable<z.ZodObject<{
+            attributes: z.ZodObject<{
+                name: z.ZodString;
+                username: z.ZodNullable<z.ZodString>;
+                email: z.ZodNullable<z.ZodString>;
+                phone1: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        deactivator: z.ZodNullable<z.ZodObject<{
+            attributes: z.ZodObject<{
+                name: z.ZodString;
+                username: z.ZodNullable<z.ZodString>;
+                email: z.ZodNullable<z.ZodString>;
+                phone1: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        device_type: z.ZodNullable<z.ZodObject<{
+            attributes: z.ZodObject<{
+                brand_alias: z.ZodNullable<z.ZodString>;
+                alias: z.ZodNullable<z.ZodString>;
+                type: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/devices/activations/schemas.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export const ActivationSchema = z.object({
+    id: z.string(),
+    attributes: z.object({
+        activated_at: z.string().nullable(),
+        deactivated_at: z.string().nullable(),
+        created_at: z.string().nullable(),
+    }),
+    relationships: z.object({
+        device: z.object({
+            attributes: z.object({
+                name: z.string().nullable(),
+                imei: z.string().nullable(),
+                code: z.string().nullable(),
+                active: z.boolean().nullable(),
+            }),
+        }).nullable(),
+        activator: z.object({
+            attributes: z.object({
+                name: z.string(),
+                username: z.string().nullable(),
+                email: z.string().nullable(),
+                phone1: z.string().nullable(),
+            }),
+        }).nullable(),
+        deactivator: z.object({
+            attributes: z.object({
+                name: z.string(),
+                username: z.string().nullable(),
+                email: z.string().nullable(),
+                phone1: z.string().nullable(),
+            }),
+        }).nullable(),
+        device_type: z.object({
+            attributes: z.object({
+                brand_alias: z.string().nullable(),
+                alias: z.string().nullable(),
+                type: z.string().nullable(),
+            }),
+        }).nullable(),
+    }),
+});

package/dist/devices/activations/types.d.ts

@@ -0,0 +1,75 @@
+import type { DeviceTypeAttr } from '../types';
+export interface ActivationAttributes {
+    activated_at: string | null;
+    deactivated_at: string | null;
+    created_at: string | null;
+}
+export interface Activation {
+    id: string;
+    attributes: ActivationAttributes;
+    relationships: {
+        device: {
+            attributes: {
+                name: string | null;
+                imei: string | null;
+                code: string | null;
+                active: boolean | null;
+            };
+        } | null;
+        activator: {
+            attributes: {
+                name: string;
+                username: string | null;
+                email: string | null;
+                phone1: string | null;
+            };
+        } | null;
+        deactivator: {
+            attributes: {
+                name: string;
+                username: string | null;
+                email: string | null;
+                phone1: string | null;
+            };
+        } | null;
+        device_type: {
+            attributes: DeviceTypeAttr;
+        } | null;
+    };
+}
+export interface ActPanelRow {
+    attributes: {
+        count: string;
+        created_at: {
+            day: string;
+        } | null;
+        activator: {
+            name: string | null;
+        } | null;
+        device: {
+            name: string | null;
+        } | null;
+        device_type: {
+            alias: string | null;
+            brand_alias: string | null;
+        } | null;
+    };
+}
+export interface DeactPanelRow {
+    attributes: {
+        count: string;
+        deleted_at: {
+            day: string;
+        } | null;
+        deactivator: {
+            name: string | null;
+        } | null;
+        device: {
+            name: string | null;
+        } | null;
+        device_type: {
+            alias: string | null;
+            brand_alias: string | null;
+        } | null;
+    };
+}

package/dist/devices/activations/types.js

@@ -0,0 +1 @@
+export {};

package/dist/devices/api.d.ts

@@ -0,0 +1,28 @@
+import type { ApiClientLike } from '../core/client';
+import type { QueryParams } from '../core/query-builder';
+import type { ActivationHistoryItem, AssociationHistoryItem, Device, DeviceModel, DevicePanelRow } from './types';
+export declare function createDevicesApi(client: ApiClientLike): {
+    listModels: (params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: DeviceModel[];
+    }>;
+    listActivationHistory: (deviceId: string, params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: ActivationHistoryItem[];
+        count: number;
+    }>;
+    listAssociationHistory: (deviceId: string, params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: AssociationHistoryItem[];
+        count: number;
+    }>;
+    panel: (params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: DevicePanelRow[];
+    }>;
+    endpoint: string;
+    list: <R = Device>(params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<import("..").ListResponse<R>>;
+    get: <R = Device>(id: string, params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: R;
+    }>;
+    create: (payload: unknown) => Promise<undefined>;
+    update: (id: string, payload: unknown) => Promise<undefined>;
+    remove: (id: string) => Promise<undefined>;
+    removeMany: (payload: unknown, signal?: AbortSignal) => Promise<undefined>;
+};

package/dist/devices/api.js

@@ -0,0 +1,11 @@
+import { createResourceApi } from '../core/client.js';
+import { withQuery } from '../core/query-builder.js';
+export function createDevicesApi(client) {
+    return {
+        ...createResourceApi(client, '/v5/devices'),
+        listModels: (params = {}, signal) => client.get(withQuery('/v5/devices/models', params), { signal }).then(r => r.data),
+        listActivationHistory: (deviceId, params = {}, signal) => client.get(withQuery(`/v5/devices/${deviceId}/activation-history`, params), { signal }).then(r => r.data),
+        listAssociationHistory: (deviceId, params = {}, signal) => client.get(withQuery(`/v5/devices/${deviceId}/association-history`, params), { signal }).then(r => r.data),
+        panel: (params = {}, signal) => client.get(withQuery('/v5/devices', params), { signal }).then(r => r.data),
+    };
+}

package/dist/devices/commands/api.d.ts

@@ -0,0 +1,17 @@
+import type { ApiClientLike } from '../../core/client';
+import type { QueryParams } from '../../core/query-builder';
+import type { Command, CommandPanelRow } from './types';
+export declare function createCommandsApi(client: ApiClientLike): {
+    panel: (params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: CommandPanelRow[];
+    }>;
+    endpoint: string;
+    list: <R = Command>(params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<import("../..").ListResponse<R>>;
+    get: <R = Command>(id: string, params?: Partial<QueryParams>, signal?: AbortSignal) => Promise<{
+        data: R;
+    }>;
+    create: (payload: unknown) => Promise<undefined>;
+    update: (id: string, payload: unknown) => Promise<undefined>;
+    remove: (id: string) => Promise<undefined>;
+    removeMany: (payload: unknown, signal?: AbortSignal) => Promise<undefined>;
+};

package/dist/devices/commands/api.js

@@ -0,0 +1,8 @@
+import { createResourceApi } from '../../core/client.js';
+import { withQuery } from '../../core/query-builder.js';
+export function createCommandsApi(client) {
+    return {
+        ...createResourceApi(client, '/v5/devices/commands-history'),
+        panel: (params = {}, signal) => client.get(withQuery('/v5/devices/commands-history', params), { signal }).then(r => r.data),
+    };
+}

package/dist/devices/commands/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './schemas';
+export * from './types';

package/dist/devices/commands/index.js

@@ -0,0 +1,3 @@
+export * from './api.js';
+export * from './schemas.js';
+export * from './types.js';