@digitraffic/common 2026.3.17-1 → 2026.3.26-1-beta

package/dist/types/openapi-schema.js

@@ -0,0 +1,151 @@
+import { z } from "zod";
+export const serverObject = z.object({
+    url: z.string(),
+    description: z.string().optional(),
+    variables: z.record(z.string(), z.unknown()).optional(),
+});
+export const parameterObject = z.object({
+    name: z.string(),
+    in: z.enum(["query", "header", "path", "cookie"]),
+    description: z.string().optional(),
+    required: z.boolean().optional(),
+    deprecated: z.boolean().optional(),
+    allowEmptyValue: z.boolean().optional(),
+    style: z
+        .enum([
+        "matrix",
+        "label",
+        "form",
+        "simple",
+        "spaceDelimited",
+        "pipeDelimited",
+        "deepObject",
+    ])
+        .optional(),
+    explode: z.string().optional(),
+    allowReserved: z.boolean().optional(),
+    schema: z.unknown().optional(),
+    example: z.unknown().optional(),
+    examples: z.record(z.string(), z.unknown()).optional(),
+    content: z.record(z.string(), z.unknown()).optional(),
+});
+export const referenceObject = z.object({
+    $ref: z.string(),
+    summary: z.string().optional(),
+    description: z.string().optional(),
+});
+export const openapiOperation = z
+    .object({
+    tags: z.array(z.string()),
+    summary: z.string(),
+    description: z.string(),
+    externalDocs: z.unknown(),
+    operationId: z.string(),
+    parameters: z.array(parameterObject.or(referenceObject)),
+    requestBody: z.unknown(),
+    responses: z.unknown(),
+    callbacks: z.unknown(),
+    deprecated: z.boolean(),
+    security: z.array(z.record(z.string(), z.array(z.string()))),
+    servers: z.array(z.unknown()),
+})
+    .partial();
+// Path items have some fixed fields but also allow for extended fields starting with "x-".
+//export const openapiPathItem = z.record(openapiOperation.or(serverObject).or(parameterObject));
+export const openapiPathItem = z
+    .object({
+    summary: z.string(),
+    description: z.string(),
+    get: openapiOperation,
+    put: openapiOperation,
+    post: openapiOperation,
+    delete: openapiOperation,
+    options: openapiOperation,
+    head: openapiOperation,
+    patch: openapiOperation,
+    trace: openapiOperation,
+    servers: serverObject,
+    parameters: z.array(parameterObject),
+})
+    .partial();
+export const openapiSchema = z
+    .object({
+    openapi: z.string().regex(/^3\.\d\.\d(-.+)?$/),
+    info: z
+        .object({
+        title: z.string(),
+        description: z.string().optional(),
+        termsOfService: z.string().optional(),
+        contact: z
+            .object({
+            name: z.string().optional(),
+            url: z.string().optional(),
+            email: z.email().optional(),
+        })
+            .strict()
+            .optional(),
+        license: z
+            .object({ name: z.string(), url: z.string().optional() })
+            .strict()
+            .optional(),
+        version: z.string(),
+    })
+        .strict(),
+    externalDocs: z
+        .object({
+        description: z.string().optional(),
+        url: z.string(),
+    })
+        .strict()
+        .optional(),
+    servers: z
+        .array(z
+        .object({
+        url: z.string(),
+        description: z.string().optional(),
+        variables: z
+            .record(z.string(), z
+            .object({
+            enum: z.array(z.string()).optional(),
+            default: z.string(),
+            description: z.string().optional(),
+        })
+            .strict())
+            .optional(),
+    })
+        .strict())
+        .optional(),
+    security: z.array(z.record(z.string(), z.array(z.string()))).optional(),
+    tags: z
+        .array(z
+        .object({
+        name: z.string(),
+        description: z.string().optional(),
+        externalDocs: z
+            .object({
+            description: z.string().optional(),
+            url: z.string(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict())
+        .optional(),
+    paths: z.record(z.string(), openapiPathItem),
+    components: z
+        .object({
+        schemas: z.record(z.string(), z.any()).optional(),
+        responses: z.record(z.string(), z.any()).optional(),
+        parameters: z.record(z.string(), z.any()).optional(),
+        examples: z.record(z.string(), z.any()).optional(),
+        requestBodies: z.record(z.string(), z.any()).optional(),
+        headers: z.record(z.string(), z.any()).optional(),
+        securitySchemes: z.record(z.string(), z.any()).optional(),
+        links: z.record(z.string(), z.any()).optional(),
+        callbacks: z.record(z.string(), z.any()).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .describe("The description of OpenAPI v3.0.x documents, as defined by https://spec.openapis.org/oas/v3.0.3");
+//# sourceMappingURL=openapi-schema.js.map

package/dist/types/traffictype.d.ts

@@ -0,0 +1,11 @@
+export declare enum TrafficType {
+    ROAD = "Road",
+    MARINE = "Marine",
+    RAIL = "Rail",
+    PARKING = "Parking",
+    AVIATION = "Aviation",
+    AFIR = "Afir",
+    MCP = "MCP",
+    CATALOG = "Catalog",
+    OTHER = "Other"
+}

package/dist/types/traffictype.js

@@ -0,0 +1,13 @@
+export var TrafficType;
+(function (TrafficType) {
+    TrafficType["ROAD"] = "Road";
+    TrafficType["MARINE"] = "Marine";
+    TrafficType["RAIL"] = "Rail";
+    TrafficType["PARKING"] = "Parking";
+    TrafficType["AVIATION"] = "Aviation";
+    TrafficType["AFIR"] = "Afir";
+    TrafficType["MCP"] = "MCP";
+    TrafficType["CATALOG"] = "Catalog";
+    TrafficType["OTHER"] = "Other";
+})(TrafficType || (TrafficType = {}));
+//# sourceMappingURL=traffictype.js.map

package/dist/types/urn.d.ts

@@ -0,0 +1 @@
+export type URN<Namespace extends string, NamespaceSpecificString extends string = ""> = `urn:${Namespace}:${NamespaceSpecificString}`;

package/dist/types/urn.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=urn.js.map

package/dist/types/util-types.d.ts

@@ -0,0 +1,11 @@
+export type ValueOf<Obj> = Obj[keyof Obj];
+/**
+ * Type-level conversion from readonly object to mutable object. Use with caution!
+ *
+ * Only converts in the type-level. Caution must be used, as the typescript cannot enforce readonly-ness at
+ * runtime. This is only useful for type-checking and especially in cases where 3rd party code requires
+ * mutable even though it is not needed.
+ */
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};

package/dist/types/util-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=util-types.js.map

package/dist/types/validator.d.ts

@@ -0,0 +1,4 @@
+export declare const MIN_YEAR = 1900;
+export declare const MAX_YEAR = 2100;
+export declare function validateYear(year: number, minYear?: number, maxYear?: number): boolean;
+export declare function validateMonth(month: number): boolean;

package/dist/types/validator.js

@@ -0,0 +1,9 @@
+export const MIN_YEAR = 1900;
+export const MAX_YEAR = 2100;
+export function validateYear(year, minYear = MIN_YEAR, maxYear = MAX_YEAR) {
+    return year >= minYear && year <= maxYear;
+}
+export function validateMonth(month) {
+    return month > 0 && month < 13;
+}
+//# sourceMappingURL=validator.js.map

package/dist/utils/api-model.d.ts

@@ -0,0 +1,51 @@
+import type { JsonSchema, Model, RequestValidator, RestApi } from "aws-cdk-lib/aws-apigateway";
+import type { ModelWithReference } from "../aws/types/model-with-reference.js";
+type ModelReferenceUrl = `https://apigateway.amazonaws.com/restapis/${string}/models/${string}`;
+/**
+ * Get a reference to an OpenAPI model object in a REST API.
+ * Can be used to supply a reference to properties of a GeoJSON feature.
+ * @param modelId Id of the referenced object
+ * @param restApiId Id of the REST API
+ */
+export declare function getModelReference(modelId: string, restApiId: string): ModelReferenceUrl;
+/**
+ * Adds a request validator to a REST API to enforce request parameters/body requirements.
+ * https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-method-request-validation.html
+ * @param api REST API
+ */
+export declare function addDefaultValidator(api: RestApi): RequestValidator;
+/**
+ * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.
+ * This method adds a schema for _a single object._
+ * @param modelName
+ * @param api REST API
+ * @param schema JSON Schema
+ * @return ModelWithReference A model object with a reference to an API Gateway model object.
+ */
+export declare function addServiceModel(modelName: string, api: RestApi, schema: JsonSchema): ModelWithReference;
+/**
+ * Add an empty JSON schema model to an API Gateway API.
+ * Usable for example if the incoming data is in XML format but some template transformation is necessary.
+ * @param modelName
+ * @param api
+ * @param contentType
+ */
+export declare function addSimpleServiceModel(modelName: string, api: RestApi, contentType?: `${string}/${string}`): Model;
+/**
+ * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.
+ * This method adds a schema for _an array._
+ * @param model
+ * @param api
+ */
+export declare function createArraySchema(model: Model, api: RestApi): JsonSchema;
+/**
+ * Creates a JSON Schema for a GeoJSON Feature. Can be used to generate OpenAPI descriptions.
+ * @param modelReference Reference to a model object
+ */
+export declare function featureSchema(modelReference: string): JsonSchema;
+/**
+ * Creates a JSON Schema for a GeoJSON Feature Collection. Can be used to generate OpenAPI descriptions.
+ * @param modelReference Reference to a model object, in this case Features.
+ */
+export declare function geojsonSchema(modelReference: string): JsonSchema;
+export {};

package/dist/utils/api-model.js

@@ -0,0 +1,118 @@
+import { JsonSchemaType, JsonSchemaVersion } from "aws-cdk-lib/aws-apigateway";
+/**
+ * Get a reference to an OpenAPI model object in a REST API.
+ * Can be used to supply a reference to properties of a GeoJSON feature.
+ * @param modelId Id of the referenced object
+ * @param restApiId Id of the REST API
+ */
+export function getModelReference(modelId, restApiId) {
+    return `https://apigateway.amazonaws.com/restapis/${restApiId}/models/${modelId}`;
+}
+/**
+ * Adds a request validator to a REST API to enforce request parameters/body requirements.
+ * https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-method-request-validation.html
+ * @param api REST API
+ */
+export function addDefaultValidator(api) {
+    return api.addRequestValidator("DefaultValidator", {
+        validateRequestParameters: true,
+        validateRequestBody: true,
+    });
+}
+/**
+ * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.
+ * This method adds a schema for _a single object._
+ * @param modelName
+ * @param api REST API
+ * @param schema JSON Schema
+ * @return ModelWithReference A model object with a reference to an API Gateway model object.
+ */
+export function addServiceModel(modelName, api, schema) {
+    const mwr = api.addModel(modelName, {
+        contentType: "application/json",
+        modelName,
+        schema,
+    });
+    mwr.modelReference = getModelReference(mwr.modelId, api.restApiId);
+    return mwr;
+}
+/**
+ * Add an empty JSON schema model to an API Gateway API.
+ * Usable for example if the incoming data is in XML format but some template transformation is necessary.
+ * @param modelName
+ * @param api
+ * @param contentType
+ */
+export function addSimpleServiceModel(modelName, api, contentType = "application/xml") {
+    return api.addModel(modelName, {
+        contentType,
+        modelName,
+        schema: {},
+    });
+}
+/**
+ * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.
+ * This method adds a schema for _an array._
+ * @param model
+ * @param api
+ */
+export function createArraySchema(model, api) {
+    return {
+        type: JsonSchemaType.ARRAY,
+        items: {
+            ref: getModelReference(model.modelId, api.restApiId),
+        },
+    };
+}
+/**
+ * Creates a JSON Schema for a GeoJSON Feature. Can be used to generate OpenAPI descriptions.
+ * @param modelReference Reference to a model object
+ */
+export function featureSchema(modelReference) {
+    return {
+        schema: JsonSchemaVersion.DRAFT4,
+        type: JsonSchemaType.OBJECT,
+        description: "GeoJson Feature",
+        required: ["type", "properties", "geometry"],
+        properties: {
+            type: {
+                type: JsonSchemaType.STRING,
+                description: "Feature",
+                enum: ["Feature"],
+            },
+            properties: {
+                ref: modelReference,
+            },
+            geometry: {
+                type: JsonSchemaType.OBJECT,
+                description: "GeoJSON geometry",
+            },
+        },
+    };
+}
+/**
+ * Creates a JSON Schema for a GeoJSON Feature Collection. Can be used to generate OpenAPI descriptions.
+ * @param modelReference Reference to a model object, in this case Features.
+ */
+export function geojsonSchema(modelReference) {
+    return {
+        schema: JsonSchemaVersion.DRAFT4,
+        type: JsonSchemaType.OBJECT,
+        description: "GeoJson FeatureCollection",
+        required: ["type", "features"],
+        properties: {
+            type: {
+                type: JsonSchemaType.STRING,
+                description: "FeatureCollection",
+                enum: ["FeatureCollection"],
+            },
+            features: {
+                type: JsonSchemaType.ARRAY,
+                items: {
+                    ref: modelReference,
+                },
+            },
+        },
+    };
+}
+//# sourceMappingURL=api-model.js.map

package/dist/utils/base64.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Encode given string to base64
+ * @param str
+ * @param encoding
+ */
+export declare function encodeBase64(str: string, encoding: BufferEncoding): string;
+/**
+ * Decode given string from base64 to given encoding
+ * @param str
+ * @param encoding
+ */
+export declare function decodeBase64(str: string, encoding: BufferEncoding): string;
+/**
+ * Encode given string from ascii to Base64 string
+ * @param token
+ */
+export declare function encodeAsciiToBase64(token: string): string;
+/**
+ * Decode given string from base64 to ascii
+ * @param str string
+ */
+export declare function decodeBase64ToAscii(str: string): string;
+/**
+ * Encode given string from base64 to utf8 string
+ * @param str
+ */
+export declare function encodeUtf8ToBase64(str: string): string;
+/**
+ * Decode given string from base64 to utf8 string. If compressed is true, decompresses it first.
+ * @param str String to decode from base64.
+ * @param compressed Whether the input string is compressed (gzip) or not.
+ */
+export declare function decodeBase64ToUtf8(str: string, compressed?: boolean): string;
+export declare function compressBuffer(buffer: Buffer): Buffer;

package/dist/utils/base64.js

@@ -0,0 +1,53 @@
+import * as zlib from "node:zlib";
+/**
+ * Encode given string to base64
+ * @param str
+ * @param encoding
+ */
+export function encodeBase64(str, encoding) {
+    return Buffer.from(str, encoding).toString("base64");
+}
+/**
+ * Decode given string from base64 to given encoding
+ * @param str
+ * @param encoding
+ */
+export function decodeBase64(str, encoding) {
+    return Buffer.from(str, "base64").toString(encoding);
+}
+/**
+ * Encode given string from ascii to Base64 string
+ * @param token
+ */
+export function encodeAsciiToBase64(token) {
+    return encodeBase64(token, "ascii");
+}
+/**
+ * Decode given string from base64 to ascii
+ * @param str string
+ */
+export function decodeBase64ToAscii(str) {
+    return decodeBase64(str, "ascii");
+}
+/**
+ * Encode given string from base64 to utf8 string
+ * @param str
+ */
+export function encodeUtf8ToBase64(str) {
+    return encodeBase64(str, "utf8");
+}
+/**
+ * Decode given string from base64 to utf8 string. If compressed is true, decompresses it first.
+ * @param str String to decode from base64.
+ * @param compressed Whether the input string is compressed (gzip) or not.
+ */
+export function decodeBase64ToUtf8(str, compressed = false) {
+    const buffer = Buffer.from(str, "base64");
+    return compressed
+        ? zlib.gunzipSync(buffer).toString("utf8")
+        : buffer.toString("utf8");
+}
+export function compressBuffer(buffer) {
+    return zlib.gzipSync(buffer);
+}
+//# sourceMappingURL=base64.js.map

package/dist/utils/date-utils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Constant for the 1970-01-01T00:00:00Z epoch Date.
+ */
+export declare const EPOCH: Date;
+export declare const UTC = "UTC";
+export declare const MYSQL_DATETIME_FORMAT = "yyyy-MM-dd HH:mm";
+/**
+ * Counts difference in milliseconds between dates.
+ * @param start
+ * @param end
+ */
+export declare function countDiffMs(start: Date, end: Date): number;
+/**
+ * Counts difference in seconds between dates.
+ * @param start
+ * @param end
+ */
+export declare function countDiffInSeconds(start: Date, end: Date): number;
+/**
+ * Converts ISO 8601 date-time -string to Date object
+ * @param isoString to convert
+ */
+export declare function dateFromIsoString(isoString: string): Date;
+/**
+ * Formats a date in UTC in the given format, regardless of system time zone
+ */
+export declare function dateToUTCString(date: Date, formatString: string): string;

package/dist/utils/date-utils.js

@@ -0,0 +1,45 @@
+import { TZDate } from "@date-fns/tz";
+import { format } from "date-fns";
+/**
+ * Constant for the 1970-01-01T00:00:00Z epoch Date.
+ */
+export const EPOCH = new Date(Date.UTC(1970, 0, 1));
+export const UTC = "UTC";
+export const MYSQL_DATETIME_FORMAT = "yyyy-MM-dd HH:mm";
+/**
+ * Counts difference in milliseconds between dates.
+ * @param start
+ * @param end
+ */
+export function countDiffMs(start, end) {
+    return end.getTime() - start.getTime();
+}
+/**
+ * Counts difference in seconds between dates.
+ * @param start
+ * @param end
+ */
+export function countDiffInSeconds(start, end) {
+    return countDiffMs(start, end) / 1000;
+}
+/**
+ * Converts ISO 8601 date-time -string to Date object
+ * @param isoString to convert
+ */
+export function dateFromIsoString(isoString) {
+    const parsed = new Date(isoString);
+    if (!isValidDate(parsed)) {
+        throw new Error(`Could not parse iso date-time string: "${isoString}" to date`);
+    }
+    return parsed;
+}
+function isValidDate(d) {
+    return d instanceof Date && !Number.isNaN(d.getTime());
+}
+/**
+ * Formats a date in UTC in the given format, regardless of system time zone
+ */
+export function dateToUTCString(date, formatString) {
+    return format(new TZDate(date, UTC), formatString);
+}
+//# sourceMappingURL=date-utils.js.map

package/dist/utils/geojson-types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * GeoJSON types
+ */
+import type { LineString, Point, Position } from "geojson";
+export declare class GeoJsonPoint implements Point {
+    readonly type: "Point";
+    readonly coordinates: Position;
+    constructor(coordinates: Position);
+}
+export declare class GeoJsonLineString implements LineString {
+    readonly type: "LineString";
+    readonly coordinates: Position[];
+    constructor(coordinates: Position[]);
+}

package/dist/utils/geojson-types.js

@@ -0,0 +1,15 @@
+export class GeoJsonPoint {
+    type = "Point";
+    coordinates;
+    constructor(coordinates) {
+        this.coordinates = coordinates;
+    }
+}
+export class GeoJsonLineString {
+    type = "LineString";
+    coordinates;
+    constructor(coordinates) {
+        this.coordinates = coordinates;
+    }
+}
+//# sourceMappingURL=geojson-types.js.map

package/dist/utils/geometry.d.ts

@@ -0,0 +1,44 @@
+/**
+ * GeoJSON functions and tools
+ */
+import type { Feature, FeatureCollection, GeoJsonProperties, Geometry, Position } from "geojson";
+export declare const SRID_WGS84 = 4326;
+/**
+ * Creates WKT geometry from GeoJSON geometry
+ * @param geometry GeoJson geometry to convert to WKT
+ */
+export declare function createGeometry(geometry: Geometry): string;
+/**
+ * Create a GeoJSON FeatureCollection from a list of GeoJSON features with a 'last updated' property.
+ * Geometry is nullable. According to the GeoJSON specification, if coordinates are unavailable,
+ * the value of geometry should be null.
+ * @param features List of Features
+ * @param lastUpdated Last updated date
+ */
+export declare function createFeatureCollection<G extends Geometry | null, P extends GeoJsonProperties>(features: Feature<G, P>[], lastUpdated: Date | null): FeatureCollection<G, P> & {
+    lastUpdated: Date | null;
+};
+export declare function isValidGeoJson<T>(json: T): boolean;
+export declare function isFeatureCollection<T>(json: T): boolean;
+/**
+ * Returns the distance between two WGS84 GeoJSON positions in kilometers. Doesn't take in account altitude.
+ * Based on the following Stack Overflow question:
+ * http://stackoverflow.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula,
+ * which is based on https://en.wikipedia.org/wiki/Haversine_formula (error rate: ~0.55%).
+ * @param pos1 first position
+ * @param pos2 second position
+ */
+export declare function distanceBetweenPositionsInKm(pos1: Position, pos2: Position): number;
+export declare function areDistinctPositions(previous: Position, next: Position): boolean;
+/**
+ * Calculates distance between two GeoJSON points (WGS84)
+ * @param pos1
+ * @param pos2
+ */
+export declare function distanceBetweenPositionsInM(pos1: Position, pos2: Position): number;
+export interface GmlLineString {
+    srsName: `${string}:${string}`;
+    posList: string;
+}
+export declare function createGmlLineString(geometry: Geometry, srsName?: `${string}:${string}`): GmlLineString;
+export declare function positionToList(position: Position, precision?: number): string;