@tmlmobilidade/types 20260121.2332.6 → 20260128.2248.28

package/dist/permissions/index.js

@@ -1,23 +1,27 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
 /* * */
 import { AgenciesPermissionSchema } from './agencies.js';
-import { AlertsRealtimePermissionSchema, AlertsScheduledPermissionSchema } from './alerts.js';
+import { AlertsPermissionSchema } from './alerts.js';
+import { AnnotationsPermissionSchema } from './annotations.js';
 import { RidesPermissionSchema, SamsPermissionSchema } from './controller.js';
-import { DatesPermissionSchema } from './dates.js';
+import { FaresPermissionSchema } from './fares.js';
 import { GtfsValidationsPermissionSchema } from './gtfs-validations.js';
 import { HomePermissionSchema } from './home.js';
+import { LinesPermissionSchema } from './lines.js';
 import { OrganizationsPermissionSchema } from './organizations.js';
 import { PerformancePermissionSchema } from './performance.js';
+import { PeriodsPermissionSchema } from './periods.js';
 import { PlansPermissionSchema } from './plans.js';
 import { RolesPermissionSchema } from './roles.js';
 import { StopsPermissionSchema } from './stops.js';
+import { TypologiesPermissionSchema } from './typologies.js';
 import { UsersPermissionSchema } from './users.js';
+import { VehiclesPermissionSchema } from './vehicles.js';
+import { ZonesPermissionSchema } from './zones.js';
 import { z } from 'zod';
 /* * */
 export const PermissionSchema = z.discriminatedUnion('scope', [
     AgenciesPermissionSchema,
-    AlertsScheduledPermissionSchema,
-    AlertsRealtimePermissionSchema,
+    AlertsPermissionSchema,
     RidesPermissionSchema,
     SamsPermissionSchema,
     GtfsValidationsPermissionSchema,
@@ -28,7 +32,13 @@ export const PermissionSchema = z.discriminatedUnion('scope', [
     RolesPermissionSchema,
     StopsPermissionSchema,
     UsersPermissionSchema,
-    DatesPermissionSchema,
+    VehiclesPermissionSchema,
+    FaresPermissionSchema,
+    AnnotationsPermissionSchema,
+    PeriodsPermissionSchema,
+    ZonesPermissionSchema,
+    TypologiesPermissionSchema,
+    LinesPermissionSchema,
 ]);
 /**
  * PermissionCatalog provides a structured catalog of all available permissions
@@ -70,6 +80,50 @@ export class PermissionCatalog {
     static get(permissionEntries, scope, action) {
         return permissionEntries.find((p) => p.scope === scope && p.action === action);
     }
+    /**
+     * Get all permissions for a given scope and set of actions in one call.
+     * More efficient than calling hasPermission or hasPermissionResource multiple times.
+     * @param args Arguments object containing permissions, scope, actions, and optional resource.
+     * @param args.resource.requireAll If true, uses hasPermissionResourceAll (user must have permission for ALL values in array). If false/undefined, uses hasPermissionResource (user needs permission for ANY value).
+     * @returns Object with boolean values for each action in the scope.
+     */
+    static getScopePermissions({ actions, permissions, resource, scope }) {
+        if (!permissions) {
+            return Object.keys(actions).reduce((acc, key) => ({ ...acc, [key]: false }), {});
+        }
+        const result = {};
+        for (const [key, action] of Object.entries(actions)) {
+            if (!action || typeof action !== 'string') {
+                result[key] = false;
+                continue;
+            }
+            if (resource) {
+                // Use hasPermissionResourceAll if requireAll is true, otherwise use hasPermissionResource
+                if (resource.requireAll) {
+                    result[key] = this.hasPermissionResourceAll({
+                        action,
+                        permissions,
+                        resource_key: resource.key,
+                        scope,
+                        value: resource.value,
+                    });
+                }
+                else {
+                    result[key] = this.hasPermissionResource({
+                        action,
+                        permissions,
+                        resource_key: resource.key,
+                        scope,
+                        value: resource.value,
+                    });
+                }
+            }
+            else {
+                result[key] = this.hasPermission(permissions, scope, action);
+            }
+        }
+        return result;
+    }
     /**
      * Check if a list of permission entries has the requested scope/action pair.
      * @param permissionEntries The list of permission entries to check against.
@@ -115,6 +169,69 @@ export class PermissionCatalog {
         // or if it contains the ALLOW_ALL_FLAG.
         if (Array.isArray(resourceValues) && resourceValues.includes(this.ALLOW_ALL_FLAG))
             return true;
+        //
+        // If value is an array, check if there's any overlap between value and resourceValues
+        if (Array.isArray(value)) {
+            if (Array.isArray(resourceValues)) {
+                return value.some(v => resourceValues.includes(v));
+            }
+            return value.includes(resourceValues);
+        }
+        //
+        // If value is not an array, check if it's in resourceValues
+        if (Array.isArray(resourceValues) && resourceValues.includes(value))
+            return true;
+        //
+        // If resourceValues is not an Array, check if it is equal to the requested value
+        if (resourceValues === value)
+            return true;
+        //
+        // Otherwise, return false
+        return false;
+        //
+    }
+    /**
+     * Checks whether the user has permission to perform a specific action
+     * within a specific scope for ALL values in an array.
+     * This is stricter than `hasPermissionResource` which only requires permission for ANY value.
+     * Use this for operations like update/delete where the user must have permission for all agencies involved.
+     * @param permissions The list of permissions (from a user or request).
+     * @param value The permission value(s) to check against - if array, ALL values must be permitted.
+     * @param resource_key The key of the resource.
+     * @param scope The scope of the permission.
+     * @param action The action of the permission.
+     * @returns True if user has permission for ALL values, false otherwise.
+     */
+    static hasPermissionResourceAll({ action, permissions, resource_key, scope, value }) {
+        //
+        //
+        // Return false if no permissions
+        if (!permissions)
+            return false;
+        //
+        // Find the permission with the given action and scope
+        const foundPermission = permissions.find(p => p.action === action && p.scope === scope);
+        if (!foundPermission)
+            return false;
+        //
+        // Check if value exists in the permission.resources[resource_key]
+        const resourceValues = foundPermission['resources']?.[resource_key];
+        if (!resourceValues)
+            return false;
+        //
+        // If resourceValues contains the ALLOW_ALL_FLAG, user has permission for everything
+        if (Array.isArray(resourceValues) && resourceValues.includes(this.ALLOW_ALL_FLAG))
+            return true;
+        //
+        // If value is an array, check if ALL elements are in resourceValues
+        if (Array.isArray(value)) {
+            if (Array.isArray(resourceValues)) {
+                return value.every(v => resourceValues.includes(v));
+            }
+            return value.every(v => v === resourceValues);
+        }
+        //
+        // If value is not an array, check if it's in resourceValues
         if (Array.isArray(resourceValues) && resourceValues.includes(value))
             return true;
         //
@@ -148,4 +265,23 @@ export class PermissionCatalog {
         // Return the cleaned permissions array
         return Object.values(cleanedPermissions);
     }
+    /**
+     * Sanitizes a list of permissions by removing any entries
+     * that do not correspond to valid scopes and actions
+     * defined in the PermissionCatalog.
+     * @param existingEntries Array of Permission objects to sanitize.
+     * @return A cleaned array containing only valid permissions.
+     */
+    static updatePermissionResource(permissionEntries, scope, action, resources) {
+        // Create a copy of the existing permissions
+        const updatedPermissions = JSON.parse(JSON.stringify(permissionEntries));
+        // Find the index of the permission to update
+        const permissionIndex = updatedPermissions.findIndex(p => p.scope === scope && p.action === action);
+        if (permissionIndex === -1)
+            return updatedPermissions;
+        // Update the permission at the found index
+        updatedPermissions[permissionIndex]['resources'] = { ...updatedPermissions[permissionIndex]['resources'], ...resources };
+        // Return the updated permissions array
+        return updatedPermissions;
+    }
 }

package/dist/permissions/lines.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const LinesPermissionSchema: z.ZodObject<{
+    action: z.ZodEnum<["create", "delete", "read", "lock", "update"]>;
+    resources: z.ZodDefault<z.ZodObject<{
+        agency_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        agency_ids: string[];
+    }, {
+        agency_ids?: string[] | undefined;
+    }>>;
+    scope: z.ZodLiteral<"lines">;
+}, "strip", z.ZodTypeAny, {
+    scope: "lines";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources: {
+        agency_ids: string[];
+    };
+}, {
+    scope: "lines";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources?: {
+        agency_ids?: string[] | undefined;
+    } | undefined;
+}>;
+export type LinesPermission = z.infer<typeof LinesPermissionSchema>;

package/dist/permissions/lines.js

@@ -0,0 +1,16 @@
+/* * */
+import { z } from 'zod';
+/* * */
+export const LinesPermissionSchema = z.object({
+    action: z.enum([
+        'create',
+        'delete',
+        'read',
+        'lock',
+        'update',
+    ]),
+    resources: z.object({
+        agency_ids: z.array(z.string()).default([]),
+    }).default({}),
+    scope: z.literal('lines'),
+});

package/dist/permissions/periods.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const PeriodsPermissionSchema: z.ZodObject<{
+    action: z.ZodEnum<["create", "delete", "read", "lock", "update"]>;
+    resources: z.ZodDefault<z.ZodObject<{
+        agency_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        agency_ids: string[];
+    }, {
+        agency_ids?: string[] | undefined;
+    }>>;
+    scope: z.ZodLiteral<"periods">;
+}, "strip", z.ZodTypeAny, {
+    scope: "periods";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources: {
+        agency_ids: string[];
+    };
+}, {
+    scope: "periods";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources?: {
+        agency_ids?: string[] | undefined;
+    } | undefined;
+}>;
+export type PeriodsPermission = z.infer<typeof PeriodsPermissionSchema>;

package/dist/permissions/periods.js

@@ -0,0 +1,16 @@
+/* * */
+import { z } from 'zod';
+/* * */
+export const PeriodsPermissionSchema = z.object({
+    action: z.enum([
+        'create',
+        'delete',
+        'read',
+        'lock',
+        'update',
+    ]),
+    resources: z.object({
+        agency_ids: z.array(z.string()).default([]),
+    }).default({}),
+    scope: z.literal('periods'),
+});

package/dist/permissions/typologies.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const TypologiesPermissionSchema: z.ZodObject<{
+    action: z.ZodEnum<["create", "delete", "read", "lock", "update"]>;
+    resources: z.ZodDefault<z.ZodObject<{
+        agency_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        agency_ids: string[];
+    }, {
+        agency_ids?: string[] | undefined;
+    }>>;
+    scope: z.ZodLiteral<"typologies">;
+}, "strip", z.ZodTypeAny, {
+    scope: "typologies";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources: {
+        agency_ids: string[];
+    };
+}, {
+    scope: "typologies";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources?: {
+        agency_ids?: string[] | undefined;
+    } | undefined;
+}>;
+export type TypologiesPermission = z.infer<typeof TypologiesPermissionSchema>;

package/dist/permissions/typologies.js

@@ -0,0 +1,16 @@
+/* * */
+import { z } from 'zod';
+/* * */
+export const TypologiesPermissionSchema = z.object({
+    action: z.enum([
+        'create',
+        'delete',
+        'read',
+        'lock',
+        'update',
+    ]),
+    resources: z.object({
+        agency_ids: z.array(z.string()).default([]),
+    }).default({}),
+    scope: z.literal('typologies'),
+});

package/dist/permissions/vehicles.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const VehiclesPermissionSchema: z.ZodObject<{
+    action: z.ZodEnum<["create", "delete", "read", "lock", "update"]>;
+    resources: z.ZodDefault<z.ZodObject<{
+        agency_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        agency_ids: string[];
+    }, {
+        agency_ids?: string[] | undefined;
+    }>>;
+    scope: z.ZodLiteral<"vehicles">;
+}, "strip", z.ZodTypeAny, {
+    scope: "vehicles";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources: {
+        agency_ids: string[];
+    };
+}, {
+    scope: "vehicles";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources?: {
+        agency_ids?: string[] | undefined;
+    } | undefined;
+}>;
+export type VehiclesPermission = z.infer<typeof VehiclesPermissionSchema>;

package/dist/permissions/vehicles.js

@@ -0,0 +1,16 @@
+/* * */
+import { z } from 'zod';
+/* * */
+export const VehiclesPermissionSchema = z.object({
+    action: z.enum([
+        'create',
+        'delete',
+        'read',
+        'lock',
+        'update',
+    ]),
+    resources: z.object({
+        agency_ids: z.array(z.string()).default([]),
+    }).default({}),
+    scope: z.literal('vehicles'),
+});

package/dist/permissions/zones.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const ZonesPermissionSchema: z.ZodObject<{
+    action: z.ZodEnum<["create", "delete", "read", "lock", "update"]>;
+    resources: z.ZodDefault<z.ZodObject<{
+        agency_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        agency_ids: string[];
+    }, {
+        agency_ids?: string[] | undefined;
+    }>>;
+    scope: z.ZodLiteral<"zones">;
+}, "strip", z.ZodTypeAny, {
+    scope: "zones";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources: {
+        agency_ids: string[];
+    };
+}, {
+    scope: "zones";
+    action: "create" | "update" | "delete" | "read" | "lock";
+    resources?: {
+        agency_ids?: string[] | undefined;
+    } | undefined;
+}>;
+export type ZonesPermission = z.infer<typeof ZonesPermissionSchema>;

package/dist/permissions/zones.js

@@ -0,0 +1,16 @@
+/* * */
+import { z } from 'zod';
+/* * */
+export const ZonesPermissionSchema = z.object({
+    action: z.enum([
+        'create',
+        'delete',
+        'read',
+        'lock',
+        'update',
+    ]),
+    resources: z.object({
+        agency_ids: z.array(z.string()).default([]),
+    }).default({}),
+    scope: z.literal('zones'),
+});