@tmlmobilidade/interfaces 20260723.1414.56 → 20260723.1550.37

package/dist/interfaces/index.d.ts

@@ -1,4 +1,3 @@
-export * from './locations/index.js';
 export * from './metrics/index.js';
 export * from './notifications/index.js';
 export * from './proposed-changes/index.js';

package/dist/interfaces/index.js

@@ -1,4 +1,3 @@
-export * from './locations/index.js';
 export * from './metrics/index.js';
 export * from './notifications/index.js';
 export * from './proposed-changes/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tmlmobilidade/interfaces",
-	"version": "20260723.1414.56",
+	"version": "20260723.1550.37",
 	"author": {
 		"email": "iso@tmlmobilidade.pt",
 		"name": "TML-ISO"

package/dist/interfaces/locations/districts.d.ts

@@ -1,13 +0,0 @@
-import { MongoCollectionClass } from '../../common/mongo-collection.js';
-import { type District } from '@tmlmobilidade/types';
-import { type IndexDescription } from 'mongodb';
-declare class DistrictsClass extends MongoCollectionClass<District, District, District> {
-    private static _instance;
-    private constructor();
-    static getInstance(): Promise<DistrictsClass>;
-    protected getCollectionIndexes(): IndexDescription[];
-    protected getCollectionName(): string;
-    protected getEnvName(): string;
-}
-export declare const districts: DistrictsClass;
-export {};

package/dist/interfaces/locations/districts.js

@@ -1,29 +0,0 @@
-/* * */
-import { MongoCollectionClass } from '../../common/mongo-collection.js';
-import { asyncSingletonProxy } from '@tmlmobilidade/utils';
-/* * */
-class DistrictsClass extends MongoCollectionClass {
-    static _instance;
-    constructor() {
-        super();
-    }
-    static async getInstance() {
-        if (!DistrictsClass._instance) {
-            const instance = new DistrictsClass();
-            await instance.connect();
-            DistrictsClass._instance = instance;
-        }
-        return DistrictsClass._instance;
-    }
-    getCollectionIndexes() {
-        return [];
-    }
-    getCollectionName() {
-        return 'districts';
-    }
-    getEnvName() {
-        return 'DATABASE_URI';
-    }
-}
-/* * */
-export const districts = asyncSingletonProxy(DistrictsClass);

package/dist/interfaces/locations/index.d.ts

@@ -1,5 +0,0 @@
-export * from './districts.js';
-export * from './localities.js';
-export * from './locations.js';
-export * from './municipalities.js';
-export * from './parishes.js';

package/dist/interfaces/locations/index.js

@@ -1,5 +0,0 @@
-export * from './districts.js';
-export * from './localities.js';
-export * from './locations.js';
-export * from './municipalities.js';
-export * from './parishes.js';

package/dist/interfaces/locations/localities.d.ts

@@ -1,13 +0,0 @@
-import { MongoCollectionClass } from '../../common/mongo-collection.js';
-import { type Locality } from '@tmlmobilidade/types';
-import { type IndexDescription } from 'mongodb';
-declare class LocalitiesClass extends MongoCollectionClass<Locality, Locality, Locality> {
-    private static _instance;
-    private constructor();
-    static getInstance(): Promise<LocalitiesClass>;
-    protected getCollectionIndexes(): IndexDescription[];
-    protected getCollectionName(): string;
-    protected getEnvName(): string;
-}
-export declare const localities: LocalitiesClass;
-export {};

package/dist/interfaces/locations/localities.js

@@ -1,29 +0,0 @@
-/* * */
-import { MongoCollectionClass } from '../../common/mongo-collection.js';
-import { asyncSingletonProxy } from '@tmlmobilidade/utils';
-/* * */
-class LocalitiesClass extends MongoCollectionClass {
-    static _instance;
-    constructor() {
-        super();
-    }
-    static async getInstance() {
-        if (!LocalitiesClass._instance) {
-            const instance = new LocalitiesClass();
-            await instance.connect();
-            LocalitiesClass._instance = instance;
-        }
-        return LocalitiesClass._instance;
-    }
-    getCollectionIndexes() {
-        return [];
-    }
-    getCollectionName() {
-        return 'localities';
-    }
-    getEnvName() {
-        return 'DATABASE_URI';
-    }
-}
-/* * */
-export const localities = asyncSingletonProxy(LocalitiesClass);

package/dist/interfaces/locations/locations.d.ts

@@ -1,43 +0,0 @@
-import { type CensusFeature, type District, type Locality, type Location, type Municipality, type Parish } from '@tmlmobilidade/types';
-import { Filter, FindOptions, WithId } from 'mongodb';
-declare class LocationsClass {
-    private static _instance;
-    private collections;
-    private mongoConnector;
-    private constructor();
-    static getInstance(): Promise<LocationsClass>;
-    countCensus: (filter?: Filter<CensusFeature>) => Promise<number>;
-    countDistricts: (filter?: Filter<District>) => Promise<number>;
-    countLocalities: (filter?: Filter<Locality>) => Promise<number>;
-    countMunicipalities: (filter?: Filter<Municipality>) => Promise<number>;
-    countParishes: (filter?: Filter<Parish>) => Promise<number>;
-    findCensus: (filter?: Filter<CensusFeature>, options?: FindOptions) => Promise<WithId<CensusFeature>[]>;
-    findDistricts: (filter?: Filter<District>, options?: FindOptions) => Promise<District[]>;
-    findLocalities: (filter?: Filter<Locality>, options?: FindOptions) => Promise<Locality[]>;
-    findMunicipalities: (filter?: Filter<Municipality>, options?: FindOptions) => Promise<Municipality[]>;
-    findParishes: (filter?: Filter<Parish>, options?: FindOptions) => Promise<Parish[]>;
-    findCensusById: (id: string, options?: FindOptions) => Promise<null | WithId<CensusFeature>>;
-    findDistrictById: (id: string, options?: FindOptions) => Promise<District | null>;
-    findLocalityById: (id: string, options?: FindOptions) => Promise<Locality | null>;
-    findMunicipalityById: (id: string, options?: FindOptions) => Promise<Municipality | null>;
-    findParishById: (id: string, options?: FindOptions) => Promise<null | Parish>;
-    findMunicipalitiesByGeo: (lat: number, lon: number, options?: FindOptions) => Promise<Municipality | null>;
-    findParishesByGeo: (lat: number, lon: number, options?: FindOptions) => Promise<null | Parish>;
-    findDistrictsByGeo: (lat: number, lon: number, options?: FindOptions) => Promise<District | null>;
-    findLocalitiesByGeo: (lat: number, lon: number, options?: FindOptions) => Promise<Locality | null>;
-    findCensusByGeo: (lat: number, lon: number, options?: FindOptions) => Promise<null | WithId<CensusFeature>>;
-    findLocationByGeo(lat: number, lon: number, { census }?: {
-        census?: boolean;
-    }): Promise<Location>;
-    private connect;
-    private findById;
-    private findMany;
-    private findOne;
-    private count;
-    private geoFilter;
-    private transformDocument;
-    private convertFilterField;
-    private convertFilter;
-}
-export declare const locations: LocationsClass;
-export {};

package/dist/interfaces/locations/locations.js

@@ -1,211 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable perfectionist/sort-classes */
-import { HTTP_STATUS, HttpException } from '@tmlmobilidade/consts';
-import { MongoConnector } from '@tmlmobilidade/mongo';
-import { asyncSingletonProxy } from '@tmlmobilidade/utils';
-/* * */
-class LocationsClass {
-    static _instance;
-    collections;
-    mongoConnector;
-    constructor() {
-        this.collections = {};
-    }
-    static async getInstance() {
-        if (!this._instance) {
-            const instance = new LocationsClass();
-            await instance.connect();
-            this._instance = instance;
-        }
-        return this._instance;
-    }
-    /*  Public Methods */
-    /* Count */
-    countCensus = async (filter) => await this.count(this.collections.census, filter);
-    countDistricts = async (filter) => {
-        const _filter = this.convertFilter(filter);
-        return await this.count(this.collections.districts, _filter);
-    };
-    countLocalities = async (filter) => {
-        const _filter = this.convertFilter(filter);
-        return await this.count(this.collections.localities, _filter);
-    };
-    countMunicipalities = async (filter) => {
-        const _filter = this.convertFilter(filter);
-        return await this.count(this.collections.municipalities, _filter);
-    };
-    countParishes = async (filter) => {
-        const _filter = this.convertFilter(filter);
-        return await this.count(this.collections.parishes, _filter);
-    };
-    /*  Find All */
-    findCensus = async (filter, options) => await this.findMany(this.collections.census, filter, options);
-    findDistricts = async (filter, options) => {
-        const _filter = this.convertFilter(filter);
-        const documents = await this.findMany(this.collections.districts, _filter, options);
-        return documents.map(doc => this.transformDocument(doc));
-    };
-    findLocalities = async (filter, options) => {
-        const _filter = this.convertFilter(filter);
-        const documents = await this.findMany(this.collections.localities, _filter, options);
-        return documents.map(doc => this.transformDocument(doc));
-    };
-    findMunicipalities = async (filter, options) => {
-        const _filter = this.convertFilter(filter);
-        const documents = await this.findMany(this.collections.municipalities, _filter, options);
-        return documents.map(doc => this.transformDocument(doc));
-    };
-    findParishes = async (filter, options) => {
-        const _filter = this.convertFilter(filter);
-        const documents = await this.findMany(this.collections.parishes, _filter, options);
-        return documents.map(doc => this.transformDocument(doc));
-    };
-    /*  Find By Id */
-    findCensusById = async (id, options) => await this.findById(this.collections.census, id, options);
-    findDistrictById = async (id, options) => {
-        const document = await this.findById(this.collections.districts, id, options);
-        return document ? this.transformDocument(document) : null;
-    };
-    findLocalityById = async (id, options) => {
-        const document = await this.findById(this.collections.localities, id, options);
-        return document ? this.transformDocument(document) : null;
-    };
-    findMunicipalityById = async (id, options) => {
-        const document = await this.findById(this.collections.municipalities, id, options);
-        return document ? this.transformDocument(document) : null;
-    };
-    findParishById = async (id, options) => {
-        const document = await this.findById(this.collections.parishes, id, options);
-        return document ? this.transformDocument(document) : null;
-    };
-    /*  Find By Geo */
-    findMunicipalitiesByGeo = async (lat, lon, options) => {
-        const document = await this.findOne(this.collections.municipalities, this.geoFilter(lat, lon), options);
-        return document ? this.transformDocument(document) : null;
-    };
-    findParishesByGeo = async (lat, lon, options) => {
-        const document = await this.findOne(this.collections.parishes, this.geoFilter(lat, lon), options);
-        return document ? this.transformDocument(document) : null;
-    };
-    findDistrictsByGeo = async (lat, lon, options) => {
-        const document = await this.findOne(this.collections.districts, this.geoFilter(lat, lon), options);
-        return document ? this.transformDocument(document) : null;
-    };
-    findLocalitiesByGeo = async (lat, lon, options) => {
-        const document = await this.findOne(this.collections.localities, this.geoFilter(lat, lon), options);
-        return document ? this.transformDocument(document) : null;
-    };
-    findCensusByGeo = async (lat, lon, options) => await this.findOne(this.collections.census, this.geoFilter(lat, lon), options);
-    async findLocationByGeo(lat, lon, { census = false } = {}) {
-        if (!lat || !lon)
-            throw new HttpException(HTTP_STATUS.BAD_REQUEST, 'Missing latitude or longitude');
-        const municipality = await this.findMunicipalitiesByGeo(lat, lon, { projection: { _id: 1, properties: 1 } });
-        const parish = await this.findParishesByGeo(lat, lon, { projection: { _id: 1, properties: 1 } });
-        const district = await this.findDistrictsByGeo(lat, lon, { projection: { _id: 1, properties: 1 } });
-        const locality = await this.findLocalitiesByGeo(lat, lon, { projection: { _id: 1, properties: 1 } });
-        const _census = census ? await this.findCensusByGeo(lat, lon, { projection: { _id: 1, properties: 1 } }) : undefined;
-        return {
-            census: { ..._census?.properties, _id: _census?._id },
-            district: district,
-            latitude: lat,
-            locality: locality,
-            longitude: lon,
-            municipality: municipality,
-            parish: parish,
-        };
-    }
-    ;
-    /*  Private Methods - Database Connection */
-    async connect() {
-        const dbUri = process.env.DATABASE_URI;
-        if (!dbUri)
-            throw new Error(`Missing DATABASE_URI environment variable`);
-        try {
-            this.mongoConnector = new MongoConnector(dbUri);
-            await this.mongoConnector.connect();
-            const db = this.mongoConnector.client.db('production');
-            this.collections = {
-                census: db.collection('census'),
-                districts: db.collection('districts'),
-                localities: db.collection('localities'),
-                municipalities: db.collection('municipalities'),
-                parishes: db.collection('parishes'),
-            };
-        }
-        catch (error) {
-            throw new Error(`Error connecting to MongoDB`, { cause: error });
-        }
-    }
-    /*  Private Methods - Database Operations */
-    async findById(collection, id, options) {
-        return collection.findOne({ _id: { $eq: id } }, options);
-    }
-    async findMany(collection, filter = {}, options) {
-        const query = collection.find(filter, options);
-        return query.toArray();
-    }
-    async findOne(collection, filter, options) {
-        return collection.findOne(filter, options);
-    }
-    async count(collection, filter = {}) {
-        return collection.countDocuments(filter);
-    }
-    geoFilter = (lat, lon) => ({ geometry: { $geoIntersects: { $geometry: { coordinates: [lon, lat], type: 'Point' } } } });
-    transformDocument(doc) {
-        const geojson = doc.geometry ? {
-            geometry: doc.geometry,
-            properties: {},
-            type: doc.type,
-        } : undefined;
-        return {
-            _id: doc._id,
-            ...doc?.properties,
-            geojson,
-        };
-    }
-    convertFilterField = (key) => {
-        if (key.startsWith('geojson.geometry'))
-            return key.replace('geojson.geometry', 'geometry');
-        if (key.startsWith('geojson.type'))
-            return key.replace('geojson.type', 'type');
-        if (key.startsWith('geojson'))
-            return key.replace('geojson', ''); // fallback
-        if (!key.startsWith('_id'))
-            return `properties.${key}`;
-        return key;
-    };
-    convertFilter = (filter) => {
-        if (!filter || typeof filter !== 'object')
-            return filter;
-        if (Array.isArray(filter)) {
-            return filter.map(this.convertFilter);
-        }
-        const output = {};
-        for (const [key, value] of Object.entries(filter)) {
-            if (key.startsWith('$')) {
-                // Recursive operator like $and, $or, $nor
-                if (Array.isArray(value)) {
-                    output[key] = value.map(this.convertFilter);
-                }
-                else if (typeof value === 'object') {
-                    output[key] = this.convertFilter(value);
-                }
-                else {
-                    output[key] = value;
-                }
-            }
-            else {
-                const newKey = this.convertFilterField(key);
-                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-                    output[newKey] = this.convertFilter(value); // nested operator (e.g., $gt)
-                }
-                else {
-                    output[newKey] = value;
-                }
-            }
-        }
-        return output;
-    };
-}
-/* * */
-export const locations = asyncSingletonProxy(LocationsClass);

package/dist/interfaces/locations/municipalities.d.ts

@@ -1,13 +0,0 @@
-import { MongoCollectionClass } from '../../common/mongo-collection.js';
-import { type Municipality } from '@tmlmobilidade/types';
-import { type IndexDescription } from 'mongodb';
-declare class MunicipalitiesClass extends MongoCollectionClass<Municipality, Municipality, Municipality> {
-    private static _instance;
-    private constructor();
-    static getInstance(): Promise<MunicipalitiesClass>;
-    protected getCollectionIndexes(): IndexDescription[];
-    protected getCollectionName(): string;
-    protected getEnvName(): string;
-}
-export declare const municipalities: MunicipalitiesClass;
-export {};

package/dist/interfaces/locations/municipalities.js

@@ -1,29 +0,0 @@
-/* * */
-import { MongoCollectionClass } from '../../common/mongo-collection.js';
-import { asyncSingletonProxy } from '@tmlmobilidade/utils';
-/* * */
-class MunicipalitiesClass extends MongoCollectionClass {
-    static _instance;
-    constructor() {
-        super();
-    }
-    static async getInstance() {
-        if (!MunicipalitiesClass._instance) {
-            const instance = new MunicipalitiesClass();
-            await instance.connect();
-            MunicipalitiesClass._instance = instance;
-        }
-        return MunicipalitiesClass._instance;
-    }
-    getCollectionIndexes() {
-        return [];
-    }
-    getCollectionName() {
-        return 'municipalities';
-    }
-    getEnvName() {
-        return 'DATABASE_URI';
-    }
-}
-/* * */
-export const municipalities = asyncSingletonProxy(MunicipalitiesClass);

package/dist/interfaces/locations/parishes.d.ts

@@ -1,13 +0,0 @@
-import { MongoCollectionClass } from '../../common/mongo-collection.js';
-import { type Parish } from '@tmlmobilidade/types';
-import { type IndexDescription } from 'mongodb';
-declare class ParishesClass extends MongoCollectionClass<Parish, Parish, Parish> {
-    private static _instance;
-    private constructor();
-    static getInstance(): Promise<ParishesClass>;
-    protected getCollectionIndexes(): IndexDescription[];
-    protected getCollectionName(): string;
-    protected getEnvName(): string;
-}
-export declare const parishes: ParishesClass;
-export {};

package/dist/interfaces/locations/parishes.js

@@ -1,29 +0,0 @@
-/* * */
-import { MongoCollectionClass } from '../../common/mongo-collection.js';
-import { asyncSingletonProxy } from '@tmlmobilidade/utils';
-/* * */
-class ParishesClass extends MongoCollectionClass {
-    static _instance;
-    constructor() {
-        super();
-    }
-    static async getInstance() {
-        if (!ParishesClass._instance) {
-            const instance = new ParishesClass();
-            await instance.connect();
-            ParishesClass._instance = instance;
-        }
-        return ParishesClass._instance;
-    }
-    getCollectionIndexes() {
-        return [];
-    }
-    getCollectionName() {
-        return 'parishes';
-    }
-    getEnvName() {
-        return 'DATABASE_URI';
-    }
-}
-/* * */
-export const parishes = asyncSingletonProxy(ParishesClass);