@uengage.io/platform-sdk 0.9.1 → 0.14.0

package/dist/zones/client.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZonesApiError = void 0;
+exports.createZonesClient = createZonesClient;
+const config_1 = require("../config");
+const http_1 = require("../http");
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+class ZonesApiError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`zones API ${status}: ${body}`);
+        this.name = 'ZonesApiError';
+        this.status = status;
+        this.body = body;
+    }
+}
+exports.ZonesApiError = ZonesApiError;
+function assertUuid(label, zid) {
+    if (typeof zid !== 'string' || !UUID_REGEX.test(zid)) {
+        throw new Error(`zones.${label}: zid must be a uuid (got ${JSON.stringify(zid)})`);
+    }
+}
+function assertPoint(label, point) {
+    const lat = point?.lat;
+    const lng = point?.lng;
+    if (typeof lat !== 'number' || typeof lng !== 'number') {
+        throw new Error(`zones.${label}: point must be { lat: number, lng: number }`);
+    }
+    if (!Number.isFinite(lat) || lat < -90 || lat > 90) {
+        throw new Error(`zones.${label}: lat must be in [-90, 90] (got ${lat})`);
+    }
+    if (!Number.isFinite(lng) || lng < -180 || lng > 180) {
+        throw new Error(`zones.${label}: lng must be in [-180, 180] (got ${lng})`);
+    }
+}
+/**
+ * Build the `zones` namespace.
+ *
+ * Shape and contract mirror {@link createBusinessClient} - lazy config
+ * resolution via {@link ConfigState}, shared 401-retry via
+ * {@link sendWithAuthRetry}, immutable per-call config; no globals.
+ *
+ * Writes (`create`, `update`, `replace`, `delete`, batch ops) require a
+ * service-actor token. Reads (`get`, `list`, `containing`, `contains`)
+ * accept either a service-actor or a user-actor token. The SDK does not
+ * enforce this - the server returns 401/403 and we surface it as
+ * {@link ZonesApiError}.
+ */
+function createZonesClient(input = {}) {
+    const state = new config_1.ConfigState();
+    state.apply(input);
+    async function send(method, path, query, body) {
+        const config = state.resolve();
+        const url = `${config.baseUrl}${path}${query ?? ''}`;
+        const payload = body === undefined ? undefined : JSON.stringify(body);
+        return (0, http_1.sendWithAuthRetry)(config, { method, path, url, body: payload });
+    }
+    async function expectJson(res) {
+        if (!res.ok)
+            throw new ZonesApiError(res.status, await res.text());
+        return (await res.json());
+    }
+    const client = {
+        config(opts) {
+            state.apply(opts);
+            return client;
+        },
+        auth(opts) {
+            state.setAuth(opts);
+            return client;
+        },
+        async create(input) {
+            if (!input || typeof input !== 'object') {
+                throw new Error('zones.create: input must be an object with `geometry`');
+            }
+            const res = await send('POST', '/v1/zones', undefined, input);
+            return expectJson(res);
+        },
+        async get(zid) {
+            assertUuid('get', zid);
+            const res = await send('GET', `/v1/zones/${zid}`);
+            return expectJson(res);
+        },
+        async update(zid, input) {
+            assertUuid('update', zid);
+            const res = await send('PATCH', `/v1/zones/${zid}`, undefined, input);
+            return expectJson(res);
+        },
+        async replace(zid, input) {
+            assertUuid('replace', zid);
+            const res = await send('PUT', `/v1/zones/${zid}`, undefined, input);
+            return expectJson(res);
+        },
+        async delete(zid) {
+            assertUuid('delete', zid);
+            const res = await send('DELETE', `/v1/zones/${zid}`);
+            if (res.status === 204)
+                return;
+            if (!res.ok)
+                throw new ZonesApiError(res.status, await res.text());
+        },
+        async list(opts = {}) {
+            const params = new URLSearchParams();
+            if (opts.tags !== undefined)
+                params.set('tags', JSON.stringify(opts.tags));
+            if (opts.cursor !== undefined)
+                params.set('cursor', opts.cursor);
+            if (opts.limit !== undefined) {
+                if (!Number.isInteger(opts.limit) || opts.limit <= 0) {
+                    throw new Error(`zones.list: limit must be a positive integer (got ${opts.limit})`);
+                }
+                params.set('limit', String(opts.limit));
+            }
+            const qs = params.toString();
+            const res = await send('GET', '/v1/zones', qs.length ? `?${qs}` : undefined);
+            return expectJson(res);
+        },
+        async createMany(zones) {
+            if (!Array.isArray(zones) || zones.length === 0) {
+                throw new Error('zones.createMany: zones must be a non-empty array');
+            }
+            const res = await send('POST', '/v1/zones/batch/create', undefined, { zones });
+            return expectJson(res);
+        },
+        async deleteMany(zids) {
+            if (!Array.isArray(zids) || zids.length === 0) {
+                throw new Error('zones.deleteMany: zids must be a non-empty array');
+            }
+            for (const zid of zids)
+                assertUuid('deleteMany', zid);
+            const res = await send('POST', '/v1/zones/batch/delete', undefined, { zids });
+            return expectJson(res);
+        },
+        async containing(input) {
+            if (!input || typeof input !== 'object') {
+                throw new Error('zones.containing: input must include `point`');
+            }
+            assertPoint('containing', input.point);
+            if (input.ids !== undefined) {
+                for (const zid of input.ids)
+                    assertUuid('containing', zid);
+            }
+            const res = await send('POST', '/v1/zones/containing', undefined, input);
+            const body = await expectJson(res);
+            return body.zones;
+        },
+        async contains(zid, point) {
+            assertUuid('contains', zid);
+            const matches = await client.containing({ point, ids: [zid] });
+            return matches.length > 0;
+        },
+    };
+    return client;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/zones/client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfigInput,\n} from '../config';\nimport { sendWithAuthRetry } from '../http';\nimport type {\n  ContainingInput,\n  Zone,\n  ZoneCreateInput,\n  ZoneCreateResult,\n  ZoneListOptions,\n  ZoneListPage,\n  ZonePatchInput,\n  ZoneReplaceInput,\n  ZoneSummary,\n} from './schema';\n\nconst UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\nexport interface ZonesClient {\n  config(input: PlatformConfigInput): ZonesClient;\n  auth(input: PlatformAuthInput | PlatformAuth): ZonesClient;\n\n  /** POST /v1/zones - create a single zone. */\n  create(input: ZoneCreateInput): Promise<ZoneCreateResult>;\n  /** GET /v1/zones/{zid} - returns the full zone or throws ZonesApiError(404). */\n  get(zid: string): Promise<Zone>;\n  /** PATCH /v1/zones/{zid} - shallow tag merge; null deletes a key. */\n  update(zid: string, input: ZonePatchInput): Promise<Zone>;\n  /** PUT /v1/zones/{zid} - full replace of geometry + tags. */\n  replace(zid: string, input: ZoneReplaceInput): Promise<Zone>;\n  /** DELETE /v1/zones/{zid} - 404 if not present. */\n  delete(zid: string): Promise<void>;\n  /** GET /v1/zones?tags=... - tag-filtered, keyset-paginated listing. */\n  list(opts?: ZoneListOptions): Promise<ZoneListPage>;\n  /** POST /v1/zones/batch/create - bounded array; returned in input order. */\n  createMany(zones: readonly ZoneCreateInput[]): Promise<{ zones: Array<{ zid: string }> }>;\n  /** POST /v1/zones/batch/delete - returns the count actually deleted. */\n  deleteMany(zids: readonly string[]): Promise<{ deleted: number }>;\n\n  /** POST /v1/zones/containing - the spatial primitive. */\n  containing(input: ContainingInput): Promise<ZoneSummary[]>;\n  /** Sugar over containing({ point, ids: [zid] }). True iff the zone contains the point. */\n  contains(zid: string, point: ContainingInput['point']): Promise<boolean>;\n}\n\nexport class ZonesApiError extends Error {\n  readonly status: number;\n  readonly body: string;\n\n  constructor(status: number, body: string) {\n    super(`zones API ${status}: ${body}`);\n    this.name = 'ZonesApiError';\n    this.status = status;\n    this.body = body;\n  }\n}\n\nfunction assertUuid(label: string, zid: string): void {\n  if (typeof zid !== 'string' || !UUID_REGEX.test(zid)) {\n    throw new Error(`zones.${label}: zid must be a uuid (got ${JSON.stringify(zid)})`);\n  }\n}\n\nfunction assertPoint(label: string, point: { lat: number; lng: number }): void {\n  const lat = point?.lat;\n  const lng = point?.lng;\n  if (typeof lat !== 'number' || typeof lng !== 'number') {\n    throw new Error(`zones.${label}: point must be { lat: number, lng: number }`);\n  }\n  if (!Number.isFinite(lat) || lat < -90 || lat > 90) {\n    throw new Error(`zones.${label}: lat must be in [-90, 90] (got ${lat})`);\n  }\n  if (!Number.isFinite(lng) || lng < -180 || lng > 180) {\n    throw new Error(`zones.${label}: lng must be in [-180, 180] (got ${lng})`);\n  }\n}\n\n/**\n * Build the `zones` namespace.\n *\n * Shape and contract mirror {@link createBusinessClient} - lazy config\n * resolution via {@link ConfigState}, shared 401-retry via\n * {@link sendWithAuthRetry}, immutable per-call config; no globals.\n *\n * Writes (`create`, `update`, `replace`, `delete`, batch ops) require a\n * service-actor token. Reads (`get`, `list`, `containing`, `contains`)\n * accept either a service-actor or a user-actor token. The SDK does not\n * enforce this - the server returns 401/403 and we surface it as\n * {@link ZonesApiError}.\n */\nexport function createZonesClient(input: PlatformConfigInput = {}): ZonesClient {\n  const state = new ConfigState();\n  state.apply(input);\n\n  async function send(\n    method: string,\n    path: string,\n    query?: string,\n    body?: unknown,\n  ): Promise<Response> {\n    const config = state.resolve();\n    const url = `${config.baseUrl}${path}${query ?? ''}`;\n    const payload = body === undefined ? undefined : JSON.stringify(body);\n    return sendWithAuthRetry(config, { method, path, url, body: payload });\n  }\n\n  async function expectJson<T>(res: Response): Promise<T> {\n    if (!res.ok) throw new ZonesApiError(res.status, await res.text());\n    return (await res.json()) as T;\n  }\n\n  const client: ZonesClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n\n    async create(input) {\n      if (!input || typeof input !== 'object') {\n        throw new Error('zones.create: input must be an object with `geometry`');\n      }\n      const res = await send('POST', '/v1/zones', undefined, input);\n      return expectJson<ZoneCreateResult>(res);\n    },\n\n    async get(zid) {\n      assertUuid('get', zid);\n      const res = await send('GET', `/v1/zones/${zid}`);\n      return expectJson<Zone>(res);\n    },\n\n    async update(zid, input) {\n      assertUuid('update', zid);\n      const res = await send('PATCH', `/v1/zones/${zid}`, undefined, input);\n      return expectJson<Zone>(res);\n    },\n\n    async replace(zid, input) {\n      assertUuid('replace', zid);\n      const res = await send('PUT', `/v1/zones/${zid}`, undefined, input);\n      return expectJson<Zone>(res);\n    },\n\n    async delete(zid) {\n      assertUuid('delete', zid);\n      const res = await send('DELETE', `/v1/zones/${zid}`);\n      if (res.status === 204) return;\n      if (!res.ok) throw new ZonesApiError(res.status, await res.text());\n    },\n\n    async list(opts = {}) {\n      const params = new URLSearchParams();\n      if (opts.tags !== undefined) params.set('tags', JSON.stringify(opts.tags));\n      if (opts.cursor !== undefined) params.set('cursor', opts.cursor);\n      if (opts.limit !== undefined) {\n        if (!Number.isInteger(opts.limit) || opts.limit <= 0) {\n          throw new Error(`zones.list: limit must be a positive integer (got ${opts.limit})`);\n        }\n        params.set('limit', String(opts.limit));\n      }\n      const qs = params.toString();\n      const res = await send('GET', '/v1/zones', qs.length ? `?${qs}` : undefined);\n      return expectJson<ZoneListPage>(res);\n    },\n\n    async createMany(zones) {\n      if (!Array.isArray(zones) || zones.length === 0) {\n        throw new Error('zones.createMany: zones must be a non-empty array');\n      }\n      const res = await send('POST', '/v1/zones/batch/create', undefined, { zones });\n      return expectJson<{ zones: Array<{ zid: string }> }>(res);\n    },\n\n    async deleteMany(zids) {\n      if (!Array.isArray(zids) || zids.length === 0) {\n        throw new Error('zones.deleteMany: zids must be a non-empty array');\n      }\n      for (const zid of zids) assertUuid('deleteMany', zid);\n      const res = await send('POST', '/v1/zones/batch/delete', undefined, { zids });\n      return expectJson<{ deleted: number }>(res);\n    },\n\n    async containing(input) {\n      if (!input || typeof input !== 'object') {\n        throw new Error('zones.containing: input must include `point`');\n      }\n      assertPoint('containing', input.point);\n      if (input.ids !== undefined) {\n        for (const zid of input.ids) assertUuid('containing', zid);\n      }\n      const res = await send('POST', '/v1/zones/containing', undefined, input);\n      const body = await expectJson<{ zones: ZoneSummary[] }>(res);\n      return body.zones;\n    },\n\n    async contains(zid, point) {\n      assertUuid('contains', zid);\n      const matches = await client.containing({ point, ids: [zid] });\n      return matches.length > 0;\n    },\n  };\n\n  return client;\n}\n"]}

package/dist/zones/index.d.ts

@@ -0,0 +1,2 @@
+export { createZonesClient, ZonesApiError, type ZonesClient } from './client';
+export type { ContainingInput, GeoJsonMultiPolygon, GeoJsonPolygon, Geometry, PatchTagBag, Point, TagBag, TagFilter, TagValue, Zone, ZoneCreateInput, ZoneCreateResult, ZoneListOptions, ZoneListPage, ZonePatchInput, ZoneReplaceInput, ZoneSummary, } from './schema';

package/dist/zones/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZonesApiError = exports.createZonesClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "createZonesClient", { enumerable: true, get: function () { return client_1.createZonesClient; } });
+Object.defineProperty(exports, "ZonesApiError", { enumerable: true, get: function () { return client_1.ZonesApiError; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvem9uZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQThFO0FBQXJFLDJHQUFBLGlCQUFpQixPQUFBO0FBQUUsdUdBQUEsYUFBYSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgY3JlYXRlWm9uZXNDbGllbnQsIFpvbmVzQXBpRXJyb3IsIHR5cGUgWm9uZXNDbGllbnQgfSBmcm9tICcuL2NsaWVudCc7XG5leHBvcnQgdHlwZSB7XG4gIENvbnRhaW5pbmdJbnB1dCxcbiAgR2VvSnNvbk11bHRpUG9seWdvbixcbiAgR2VvSnNvblBvbHlnb24sXG4gIEdlb21ldHJ5LFxuICBQYXRjaFRhZ0JhZyxcbiAgUG9pbnQsXG4gIFRhZ0JhZyxcbiAgVGFnRmlsdGVyLFxuICBUYWdWYWx1ZSxcbiAgWm9uZSxcbiAgWm9uZUNyZWF0ZUlucHV0LFxuICBab25lQ3JlYXRlUmVzdWx0LFxuICBab25lTGlzdE9wdGlvbnMsXG4gIFpvbmVMaXN0UGFnZSxcbiAgWm9uZVBhdGNoSW5wdXQsXG4gIFpvbmVSZXBsYWNlSW5wdXQsXG4gIFpvbmVTdW1tYXJ5LFxufSBmcm9tICcuL3NjaGVtYSc7XG4iXX0=

package/dist/zones/schema.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Type surface for the platform Zones API.
+ *
+ * The Zones service is a generic, domain-agnostic spatial primitive: it stores
+ * tagged polygons and answers point-in-polygon containment queries. It knows
+ * nothing about businesses, serviceability, or delivery; those are consumer
+ * concerns that compose this primitive.
+ *
+ * Coordinate convention everywhere in this surface: points are the named
+ * object `{ lat, lng }` (never a positional pair). The service converts
+ * internally to the PostGIS lng-first order. Polygons follow GeoJSON axis
+ * order `[lng, lat]` per the GeoJSON spec.
+ */
+/** Latitude/longitude pair. Lat in [-90, 90], lng in [-180, 180]. */
+export interface Point {
+    lat: number;
+    lng: number;
+}
+/**
+ * GeoJSON-2008 Polygon. The first ring is the exterior; subsequent rings
+ * are interior (holes). Each coordinate is `[lng, lat]`.
+ */
+export interface GeoJsonPolygon {
+    type: 'Polygon';
+    coordinates: Array<Array<[number, number]>>;
+}
+/**
+ * GeoJSON-2008 MultiPolygon. The service normalises Polygon to MultiPolygon
+ * on write, so reads always return MultiPolygon.
+ */
+export interface GeoJsonMultiPolygon {
+    type: 'MultiPolygon';
+    coordinates: Array<Array<Array<[number, number]>>>;
+}
+export type Geometry = GeoJsonPolygon | GeoJsonMultiPolygon;
+/**
+ * Tag values are flat: a scalar (coerced to string by the service) or a
+ * flat array of scalars. Nested objects are rejected on write.
+ *
+ * `null` is meaningful only inside a PATCH tag bag, where it deletes the
+ * key. It is not a storable value. Use {@link PatchTagBag} for PATCH bodies.
+ */
+export type TagValue = string | string[];
+export type TagBag = Record<string, TagValue>;
+/** Tag bag accepted by PATCH. `null` deletes the key; everything else is shallow-merged. */
+export type PatchTagBag = Record<string, TagValue | null>;
+/**
+ * Filter grammar used by both the listing endpoint and the containment
+ * primitive's `tags` selector:
+ *
+ *   - `{ k: "v" }`           equality / array-membership: `tags @> {"k":"v"}`
+ *   - `{ k: ["v1","v2"] }`   any-of (IN): per-value `@>` clauses OR-ed
+ *   - multiple keys           AND across keys
+ *
+ * Stored arrays match scalar filters via JSONB `@>`; the compiler does not
+ * need to know the stored shape. Use the dedicated `ids` selector on
+ * containment for large id-style sets — tag IN is for low-cardinality
+ * value lists (category, status, type).
+ */
+export type TagFilter = Record<string, string | string[]>;
+/** The full zone record returned by `get`/`replace`/`update`. */
+export interface Zone {
+    zid: string;
+    geometry: GeoJsonMultiPolygon;
+    tags: TagBag;
+    createdAt: string;
+    updatedAt: string;
+}
+/** The compact shape returned by `containing`, `list`, and `create`. */
+export interface ZoneSummary {
+    zid: string;
+    tags: TagBag;
+}
+export interface ZoneListPage {
+    zones: ZoneSummary[];
+    nextCursor: string | null;
+}
+export interface ZoneCreateResult {
+    zid: string;
+    tags: TagBag;
+    createdAt: string;
+}
+export interface ZoneCreateInput {
+    geometry: Geometry;
+    tags?: TagBag;
+}
+export interface ZonePatchInput {
+    geometry?: Geometry;
+    tags?: PatchTagBag;
+}
+export interface ZoneReplaceInput {
+    geometry: Geometry;
+    tags?: TagBag;
+}
+export interface ZoneListOptions {
+    tags?: TagFilter;
+    cursor?: string;
+    limit?: number;
+}
+export interface ContainingInput {
+    point: Point;
+    ids?: readonly string[];
+    tags?: TagFilter;
+}

package/dist/zones/schema.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Type surface for the platform Zones API.
+ *
+ * The Zones service is a generic, domain-agnostic spatial primitive: it stores
+ * tagged polygons and answers point-in-polygon containment queries. It knows
+ * nothing about businesses, serviceability, or delivery; those are consumer
+ * concerns that compose this primitive.
+ *
+ * Coordinate convention everywhere in this surface: points are the named
+ * object `{ lat, lng }` (never a positional pair). The service converts
+ * internally to the PostGIS lng-first order. Polygons follow GeoJSON axis
+ * order `[lng, lat]` per the GeoJSON spec.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uengage.io/platform-sdk",
-  "version": "0.9.1",
-  "description": "Client SDK for the uEngage platform API (audit, business, auth). Single createClient(...) factory; OAuth2 client_credentials, static Bearer, or legacy session-token auth modes.",
+  "version": "0.14.0",
+  "description": "Client SDK for the uEngage platform API (audit, business, zones, wallet, auth). Single createClient(...) factory; OAuth2 client_credentials, static Bearer, or legacy session-token auth modes.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [