@jantstack/adonis-authz 1.0.0

package/build/src/traits/has_uuid.d.ts

@@ -0,0 +1,151 @@
+import type { BaseModel } from '@adonisjs/lucid/orm';
+import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
+/**
+ * Trait para asignar automáticamente UUIDv7 en la PK del modelo.
+ * Autodetecta correctamente la primaryKey desde la instancia real.
+ */
+export declare const hasUuid: <Model extends NormalizeConstructor<typeof BaseModel>>(superclass: Model) => {
+    new (...args: any[]): {
+        $attributes: import("@adonisjs/lucid/types/model").ModelObject;
+        $extras: import("@adonisjs/lucid/types/model").ModelObject;
+        $original: import("@adonisjs/lucid/types/model").ModelObject;
+        $preloaded: {
+            [relation: string]: import("@adonisjs/lucid/types/model").LucidRow | import("@adonisjs/lucid/types/model").LucidRow[];
+        };
+        $sideloaded: import("@adonisjs/lucid/types/model").ModelObject;
+        $primaryKeyValue?: number | string;
+        $isPersisted: boolean;
+        $isNew: boolean;
+        $isLocal: boolean;
+        $dirty: import("@adonisjs/lucid/types/model").ModelObject;
+        $isDirty: boolean;
+        $isDeleted: boolean;
+        $options?: import("@adonisjs/lucid/types/model").ModelOptions;
+        $trx?: import("@adonisjs/lucid/types/database").TransactionClientContract;
+        $setOptionsAndTrx(options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): void;
+        useTransaction(trx: import("@adonisjs/lucid/types/database").TransactionClientContract): /*elided*/ any;
+        useConnection(connection: string): /*elided*/ any;
+        $getQueryFor(action: "insert", client: import("@adonisjs/lucid/types/database").QueryClientContract): ReturnType<import("@adonisjs/lucid/types/database").QueryClientContract["insertQuery"]>;
+        $getQueryFor(action: "update" | "delete" | "refresh", client: import("@adonisjs/lucid/types/database").QueryClientContract): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel>;
+        $setAttribute(key: string, value: any): void;
+        $getAttribute(key: string): any;
+        $getAttributeFromCache(key: string, callback: import("@adonisjs/lucid/types/model").CacheNode["getter"]): any;
+        $hasRelated(key: string): boolean;
+        $setRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
+        $pushRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
+        $getRelated(key: string, defaultValue?: any): import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | undefined | null;
+        $consumeAdapterResult(adapterResult: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject): void;
+        $hydrateOriginals(): void;
+        fill(value: Partial<import("@adonisjs/lucid/types/model").ModelAttributes</*elided*/ any>>, allowExtraProperties?: boolean): /*elided*/ any;
+        merge(value: Partial<import("@adonisjs/lucid/types/model").ModelAttributes</*elided*/ any>>, allowExtraProperties?: boolean): /*elided*/ any;
+        isDirty(fields?: undefined[] | undefined): boolean;
+        enableForceUpdate(): /*elided*/ any;
+        save(): Promise</*elided*/ any>;
+        saveQuietly(): Promise</*elided*/ any>;
+        lockForUpdate<T>(callback: (user: /*elided*/ any) => T | Promise<T>): Promise<T>;
+        delete(): Promise<void>;
+        deleteQuietly(): Promise<void>;
+        refresh(): Promise</*elided*/ any>;
+        load: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
+        loadOnce: import("@adonisjs/lucid/types/model").LucidRowPreloadOnce</*elided*/ any>;
+        preload: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
+        loadAggregate: <Self extends /*elided*/ any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? (import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        loadCount: <Self extends /*elided*/ any, Name_1 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder_1 = NonNullable<Self[Name_1]> extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? (import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> & Self[Name_1] & {})["subQuery"] : never>(name: Name_1, callback?: ((builder: RelatedBuilder_1) => void) | undefined) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        serializeAttributes(fields?: import("@adonisjs/lucid/types/model").CherryPickFields, raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeComputed(fields?: import("@adonisjs/lucid/types/model").CherryPickFields): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeRelations(fields: undefined, raw: true): {
+            [key: string]: import("@adonisjs/lucid/types/model").LucidRow | import("@adonisjs/lucid/types/model").LucidRow[];
+        };
+        serializeRelations(cherryPick: import("@adonisjs/lucid/types/model").CherryPick["relations"] | undefined, raw: false | undefined): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeRelations(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick["relations"], raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
+        serialize(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick): import("@adonisjs/lucid/types/model").ModelObject;
+        toObject(): import("@adonisjs/lucid/types/model").ModelObject;
+        toJSON(): import("@adonisjs/lucid/types/model").ModelObject;
+        toAttributes(): Record<string, any>;
+        related<Name_2 extends undefined>(relation: Name_2): NonNullable</*elided*/ any[Name_2]> extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? (import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> & /*elided*/ any[Name_2] & {})["client"] : never;
+    };
+    selfAssignPrimaryKey: boolean;
+    generateUuid(model: any): void;
+    /** Devuelve un nuevo UUID v7 (para uso en pivots u otros datos que no son instancias del modelo). */
+    nextUuid(): string;
+    find: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    readonly booted: boolean;
+    $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
+    $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
+    $computedDefinitions: Map<string, import("@adonisjs/lucid/types/model").ComputedOptions>;
+    primaryKey: string;
+    connection?: string | undefined;
+    namingStrategy: import("@adonisjs/lucid/types/model").NamingStrategyContract;
+    table: string;
+    $adapter: import("@adonisjs/lucid/types/model").AdapterContract;
+    useAdapter: (adapter: import("@adonisjs/lucid/types/model").AdapterContract) => void;
+    $hooks: import("@poppinss/hooks").default<any>;
+    $keys: {
+        attributesToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        attributesToSerialized: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        columnsToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        columnsToSerialized: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        serializedToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        serializedToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        columnAliasesToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
+    };
+    $createFromAdapterResult: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, result?: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => null | InstanceType<T>;
+    $createMultipleFromAdapterResult: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => InstanceType<T>[];
+    $addColumn: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ColumnOptions>) => import("@adonisjs/lucid/types/model").ColumnOptions;
+    $hasColumn: (name: string) => boolean;
+    $getColumn: (name: string) => import("@adonisjs/lucid/types/model").ModelColumnOptions | undefined;
+    $getColumnAlias: (columnName: string) => string;
+    columnsForSelect: () => Record<string, string>;
+    $addComputed: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ComputedOptions>) => import("@adonisjs/lucid/types/model").ComputedOptions;
+    $hasComputed: (name: string) => boolean;
+    $getComputed: (name: string) => import("@adonisjs/lucid/types/model").ComputedOptions | undefined;
+    $addRelation: (name: string, type: import("@adonisjs/lucid/types/relations").ModelRelationTypes["__opaque_type"], relatedModel: () => import("@adonisjs/lucid/types/model").LucidModel, options: import("@adonisjs/lucid/types/model").ModelRelationOptions) => void;
+    $hasRelation: (name: string) => boolean;
+    $getRelation: {
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Name_2 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<InstanceType<Model_1>>>(this: Model_1, name: Name_2): NonNullable<InstanceType<Model_1>[Name_2]> extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? NonNullable<InstanceType<Model_1>[Name_2]>["client"]["relation"] : import("@adonisjs/lucid/types/relations").RelationshipsContract;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
+    };
+    $defineProperty: <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model_1>(this: Model_1, propertyName: Prop, defaultValue: Model_1[Prop], strategy: "inherit" | "define" | ((value: Model_1[Prop]) => Model_1[Prop])) => void;
+    boot: () => void;
+    before: {
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model_1, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, Event>): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>], "paginate">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_1>): void;
+    };
+    after: {
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>[], "fetch">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_1>>, "paginate">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): void;
+    };
+    create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    createQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    createManyQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    findOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
+    findBy: {
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
+    };
+    findByOrFail: {
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
+    };
+    findManyBy: {
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
+    };
+    first: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    firstOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
+    findMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
+    firstOrNew: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    firstOrCreate: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    updateOrCreate: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    fetchOrNewUpMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    fetchOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    updateOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    all: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
+    query: <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Result = InstanceType<Model_1>>(this: Model_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1, Result>;
+    transaction: import("@adonisjs/lucid/types/database").TransactionFn;
+    truncate: (cascade?: boolean) => Promise<void>;
+} & Model;
+//# sourceMappingURL=has_uuid.d.ts.map

package/build/src/traits/has_uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has_uuid.d.ts","sourceRoot":"","sources":["../../../src/traits/has_uuid.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAGxE;;;GAGG;AACH,eAAO,MAAM,OAAO,GAAI,KAAK,SAAS,oBAAoB,CAAC,OAAO,SAAS,CAAC,EAC1E,YAAY,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAMY,GAAG;IAO9B,qGAAqG;gBAClF,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kaAM0jtB,oDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SADvotB,CAAA"}

package/build/src/traits/has_uuid.js

@@ -0,0 +1,38 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { beforeCreate } from '@adonisjs/lucid/orm';
+import { v7 as uuidv7 } from 'uuid';
+/**
+ * Trait para asignar automáticamente UUIDv7 en la PK del modelo.
+ * Autodetecta correctamente la primaryKey desde la instancia real.
+ */
+export const hasUuid = (superclass) => {
+    class WithPrimaryUuidClass extends superclass {
+        static selfAssignPrimaryKey = true;
+        static generateUuid(model) {
+            const pk = model.constructor.primaryKey ?? 'id';
+            if (!model[pk]) {
+                model[pk] = uuidv7();
+            }
+        }
+        /** Devuelve un nuevo UUID v7 (para uso en pivots u otros datos que no son instancias del modelo). */
+        static nextUuid() {
+            return uuidv7();
+        }
+    }
+    __decorate([
+        beforeCreate(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], WithPrimaryUuidClass, "generateUuid", null);
+    return WithPrimaryUuidClass;
+};
+//# sourceMappingURL=has_uuid.js.map

package/build/src/traits/has_uuid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has_uuid.js","sourceRoot":"","sources":["../../../src/traits/has_uuid.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,EAAE,EAAE,IAAI,MAAM,EAAE,MAAM,MAAM,CAAA;AAEnC;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,UAAiB,EACjB,EAAE;IACF,MAAM,oBAAqB,SAAQ,UAAU;QAC3C,MAAM,CAAC,oBAAoB,GAAG,IAAI,CAAA;QAG3B,AAAP,MAAM,CAAC,YAAY,CAAC,KAAU;YAC5B,MAAM,EAAE,GAAG,KAAK,CAAC,WAAW,CAAC,UAAU,IAAI,IAAI,CAAA;YAC/C,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;gBACf,KAAK,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAA;YACtB,CAAC;QACH,CAAC;QAED,qGAAqG;QACrG,MAAM,CAAC,QAAQ;YACb,OAAO,MAAM,EAAE,CAAA;QACjB,CAAC;;IAVM;QADN,YAAY,EAAE;;;;kDAMd;IAOH,OAAO,oBAAoB,CAAA;AAC7B,CAAC,CAAA"}

package/build/src/types.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Contrato del sistema de autorización del chasis (puerto + drivers).
+ *
+ * El chasis NO condena a un backend concreto: todo call-site (middleware,
+ * services, seeders) habla con este contrato a través del manager
+ * (`#services/authorization/main`). El driver `database` (motor propio sobre
+ * las tablas `authz_*`) es el default autosuficiente; un driver `openfga` u
+ * otro custom se registra en `config/authorization.ts` sin tocar call-sites.
+ *
+ * ── Semántica que TODO driver debe respetar ──────────────────────────────
+ * La verifica `tests/contracts/authorization_driver_contract.ts` (la misma
+ * suite corre contra cada driver — es el juez del contrato):
+ *
+ * 1. **Scopes jerárquicos, herencia SOLO hacia abajo.** La cadena de un scope
+ *    es `[scope, ...ancestros]` (`app` es la raíz: su cadena es él mismo).
+ *    Un grant en un scope autoriza en ese scope y en TODOS sus descendientes;
+ *    nunca en hermanos ni ancestros. En T1 solo opera `app` (los ancestros de
+ *    `organization`/`unit` se completan en T2/T3 vía `resolveAncestors`).
+ * 2. **Deny explícito gana.** Un deny de un permiso en cualquier scope de la
+ *    cadena bloquea `authorize`, aunque un rol lo conceda (el deny también
+ *    hereda hacia abajo). Quitar el deny restaura el permiso.
+ * 3. **Expiración observable.** Una asignación con `expiresAt` en el pasado
+ *    no concede nada; con `expiresAt` futuro concede normalmente.
+ * 4. **Holder polimórfico.** `SubjectRef.type` es el morph name del modelo
+ *    (`users` | `admins` | `integrations` | los del consumidor). Dos holders
+ *    con el mismo uuid y distinto type JAMÁS se cruzan.
+ * 5. **Denegación por defecto.** Permiso desconocido, rol sin el permiso o
+ *    holder sin asignación vigente → `false`, nunca throw en `authorize`.
+ *    En cambio `grant`/`deny` con rol/permiso fuera del catálogo → throw
+ *    (error de programación, no de autorización).
+ * 6. **Idempotencia de escritura.** Re-`grant` no duplica (actualiza
+ *    `expiresAt`); re-`revoke`/re-`deny`/re-`removeDeny` son no-ops seguros.
+ */
+/** Referencia polimórfica al holder: morph name + uuid. */
+export interface SubjectRef {
+    type: string;
+    uuid: string;
+}
+/**
+ * Nivel de scope. El motor solo conoce la raíz (`app`, uuid null); los demás
+ * niveles los define el CONSUMIDOR — `organization`/`unit` en este chasis,
+ * pero podrían ser `project`, `site`, `case`… El árbol lo declara el
+ * `ScopeAncestorsResolver` que se inyecta a los drivers, así que el motor no
+ * necesita conocer la taxonomía.
+ *
+ * Un consumidor que quiera seguridad de tipos define su propia unión:
+ *   type MyScope = 'app' | 'organization' | 'unit'
+ */
+export type ScopeType = string;
+/** Nombre reservado del scope raíz. */
+export declare const APP_SCOPE_TYPE = "app";
+export interface ScopeRef {
+    type: ScopeType;
+    /** `null` solo para `app` (scope global sin entidad). */
+    uuid: string | null;
+}
+/** El scope raíz de aplicación (nivel plataforma). */
+export declare const APP_SCOPE: ScopeRef;
+export interface GrantOptions {
+    /** Expiración de la asignación. `null`/omitido = sin expiración. */
+    expiresAt?: Date | null;
+}
+export interface AuthorizationDriver {
+    /**
+     * ¿El holder tiene el permiso en el scope? Evalúa la cadena completa:
+     * sin deny en la cadena Y alguna asignación vigente cuyo rol concede el
+     * permiso. Nunca lanza: desconocido = false.
+     */
+    authorize(subject: SubjectRef, permission: string, scope: ScopeRef): Promise<boolean>;
+    /**
+     * Asigna un rol al holder en un scope. El rol debe existir en el catálogo
+     * para `scope.type` (throw si no). Idempotente: re-grant actualiza expiresAt.
+     */
+    grant(subject: SubjectRef, role: string, scope: ScopeRef, options?: GrantOptions): Promise<void>;
+    /** Quita la asignación del rol en ese scope exacto. No-op si no existía. */
+    revoke(subject: SubjectRef, role: string, scope: ScopeRef): Promise<void>;
+    /**
+     * ¿El holder tiene el rol (vigente) en el scope o en un ancestro?
+     * Misma regla de herencia hacia abajo que `authorize`.
+     */
+    hasRole(subject: SubjectRef, role: string, scope: ScopeRef): Promise<boolean>;
+    /**
+     * Deny explícito de UN permiso al holder en un scope (y sus descendientes).
+     * El permiso debe existir en el catálogo (throw si no). Idempotente.
+     */
+    deny(subject: SubjectRef, permission: string, scope: ScopeRef): Promise<void>;
+    /** Levanta el deny en ese scope exacto. No-op si no existía. */
+    removeDeny(subject: SubjectRef, permission: string, scope: ScopeRef): Promise<void>;
+    /** Holders con asignación VIGENTE del rol en ese scope exacto (sin herencia). */
+    listSubjects(role: string, scope: ScopeRef): Promise<SubjectRef[]>;
+    /** Roles (slugs) con asignación DIRECTA vigente del holder en ese scope exacto. */
+    listRoles(subject: SubjectRef, scope: ScopeRef): Promise<string[]>;
+    /**
+     * Scopes del tipo dado donde el holder tiene alguna asignación DIRECTA
+     * vigente de rol. Base de "membresía" (¿de qué organizations es miembro?).
+     */
+    listRoleScopes(subject: SubjectRef, scopeType: ScopeType): Promise<ScopeRef[]>;
+    /**
+     * Scopes con asignación DIRECTA vigente que concede el permiso, excluyendo
+     * los bloqueados por deny. No enumera descendientes heredados (sería
+     * abierto): el caller consulta `authorize` sobre un scope concreto.
+     */
+    listScopes(subject: SubjectRef, permission: string): Promise<ScopeRef[]>;
+}
+/** Factory registrable en `config/authorization.ts`. */
+export type AuthorizationDriverFactory = () => AuthorizationDriver | Promise<AuthorizationDriver>;
+/**
+ * Resolutor de ancestros de un scope (del más cercano a la raíz). El paquete
+ * NO conoce el dominio del consumidor: el chasis inyecta el suyo (que sabe de
+ * organizations/organization_units) al construir cada driver en el config.
+ * Default de los drivers sin resolutor: `app` → [], resto → [APP_SCOPE].
+ */
+export type ScopeAncestorsResolver = (scope: ScopeRef) => Promise<ScopeRef[]>;
+/**
+ * Escritura del motor, notificada al hook `onWrite` del config. El chasis lo
+ * usa para auditar/emitir SSE; un consumidor puede loguear, notificar, etc.
+ */
+export interface AuthzWriteEvent {
+    action: 'granted' | 'revoked' | 'denied' | 'deny_removed';
+    subject: SubjectRef;
+    scope: ScopeRef;
+    /** Presente en granted/revoked. */
+    role?: string;
+    /** Presente en denied/deny_removed. */
+    permission?: string;
+    expiresAt?: Date | null;
+}
+export interface CatalogRoleSpec {
+    /** UUID fijo opcional (mismo patrón que organization_acl: estable entre entornos). */
+    uuid?: string;
+    slug: string;
+    /** Nivel al que este rol es asignable. */
+    scopeType: ScopeType;
+    name?: string;
+    description?: string | null;
+    /**
+     * Rango del rol (mayor = más privilegio). Lo usa la POLICY de asignación
+     * del consumidor ("no puedes otorgar/quitar un rol de rango ≥ al tuyo");
+     * el motor lo almacena como metadata pero no lo evalúa en authorize().
+     */
+    rank?: number;
+    /** Slugs de permisos (`recurso:accion`) que el rol concede. */
+    permissions: string[];
+}
+export interface CatalogSpec {
+    /** Todos los permisos del catálogo (formato `recurso:accion`). */
+    permissions: Array<{
+        slug: string;
+        description?: string | null;
+    }>;
+    roles: CatalogRoleSpec[];
+}
+//# sourceMappingURL=types.d.ts.map

package/build/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/build/src/types.js

@@ -0,0 +1,38 @@
+/**
+ * Contrato del sistema de autorización del chasis (puerto + drivers).
+ *
+ * El chasis NO condena a un backend concreto: todo call-site (middleware,
+ * services, seeders) habla con este contrato a través del manager
+ * (`#services/authorization/main`). El driver `database` (motor propio sobre
+ * las tablas `authz_*`) es el default autosuficiente; un driver `openfga` u
+ * otro custom se registra en `config/authorization.ts` sin tocar call-sites.
+ *
+ * ── Semántica que TODO driver debe respetar ──────────────────────────────
+ * La verifica `tests/contracts/authorization_driver_contract.ts` (la misma
+ * suite corre contra cada driver — es el juez del contrato):
+ *
+ * 1. **Scopes jerárquicos, herencia SOLO hacia abajo.** La cadena de un scope
+ *    es `[scope, ...ancestros]` (`app` es la raíz: su cadena es él mismo).
+ *    Un grant en un scope autoriza en ese scope y en TODOS sus descendientes;
+ *    nunca en hermanos ni ancestros. En T1 solo opera `app` (los ancestros de
+ *    `organization`/`unit` se completan en T2/T3 vía `resolveAncestors`).
+ * 2. **Deny explícito gana.** Un deny de un permiso en cualquier scope de la
+ *    cadena bloquea `authorize`, aunque un rol lo conceda (el deny también
+ *    hereda hacia abajo). Quitar el deny restaura el permiso.
+ * 3. **Expiración observable.** Una asignación con `expiresAt` en el pasado
+ *    no concede nada; con `expiresAt` futuro concede normalmente.
+ * 4. **Holder polimórfico.** `SubjectRef.type` es el morph name del modelo
+ *    (`users` | `admins` | `integrations` | los del consumidor). Dos holders
+ *    con el mismo uuid y distinto type JAMÁS se cruzan.
+ * 5. **Denegación por defecto.** Permiso desconocido, rol sin el permiso o
+ *    holder sin asignación vigente → `false`, nunca throw en `authorize`.
+ *    En cambio `grant`/`deny` con rol/permiso fuera del catálogo → throw
+ *    (error de programación, no de autorización).
+ * 6. **Idempotencia de escritura.** Re-`grant` no duplica (actualiza
+ *    `expiresAt`); re-`revoke`/re-`deny`/re-`removeDeny` son no-ops seguros.
+ */
+/** Nombre reservado del scope raíz. */
+export const APP_SCOPE_TYPE = 'app';
+/** El scope raíz de aplicación (nivel plataforma). */
+export const APP_SCOPE = Object.freeze({ type: 'app', uuid: null });
+//# sourceMappingURL=types.js.map

package/build/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAoBH,uCAAuC;AACvC,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,CAAA;AAQnC,sDAAsD;AACtD,MAAM,CAAC,MAAM,SAAS,GAAa,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAA"}

package/build/stubs/config/app_acl.stub

@@ -0,0 +1,81 @@
+{{{
+  exports({ to: app.configPath('app_acl.ts') })
+}}}
+import type { CatalogSpec } from '@jantstack/adonis-authz'
+
+/**
+ * Catálogo del ACL de NIVEL APLICACIÓN (scope `app` del motor de
+ * autorización propio). Single source of truth de roles/permisos de
+ * plataforma: lo sincroniza `database/seeder_source/app_acl_seeder.ts`
+ * (idempotente y aditivo, mismo contrato que organization_acl).
+ *
+ * Gramática unificada con las abilities de tokens (M3): los slugs usan
+ * `recurso:accion` y se registran en el registry de abilities
+ * (`start/authz.ts`) — un token delegado puede acotar EXACTAMENTE con los
+ * mismos nombres que el ACL concede.
+ *
+ * Para el ACL POR TENANT ver `config/organization_acl.ts` (migra al motor
+ * en la tanda 2).
+ *
+ * Workflow para añadir un permiso:
+ *   1. Editar este archivo.
+ *   2. `node ace db:seed:one app_acl_seeder`
+ */
+const appAclConfig = {
+  /**
+   * Permisos de plataforma del chasis. El derivado añade los suyos aquí
+   * (formato `recurso:accion` en minúsculas).
+   */
+  permissions: [
+    { slug: 'audit:read', description: 'Leer el log de auditoría global de la plataforma' },
+    { slug: 'admin:manage', description: 'Gestionar admins y sus roles de plataforma' },
+    { slug: 'organizations:read', description: 'Leer cualquier organization de la plataforma' },
+  ],
+
+  /**
+   * Roles asignables a nivel app (típicamente a holders del guard admins).
+   * UUIDs fijos: mismo uuid en todos los entornos (patrón organization_acl).
+   * `permissions: '*'` = todos los permisos del catálogo.
+   */
+  roles: [
+    {
+      uuid: '019da000-0002-7000-8000-000000000001',
+      slug: 'superadmin',
+      name: 'Superadmin',
+      description: 'Acceso total al plano de administración de la plataforma.',
+      rank: 100,
+      permissions: '*' as const,
+    },
+    {
+      uuid: '019da000-0002-7000-8000-000000000002',
+      slug: 'support',
+      name: 'Support',
+      description: 'Soporte: lectura de auditoría y organizations, sin gestión de admins.',
+      rank: 50,
+      permissions: ['audit:read', 'organizations:read'],
+    },
+  ],
+}
+
+/** Slugs de permisos del nivel app (se registran como abilities — M3). */
+export function appPermissionSlugs(): string[] {
+  return appAclConfig.permissions.map((p) => p.slug)
+}
+
+/** El catálogo en el formato del motor (`syncAuthzCatalog`). */
+export function appAclCatalog(): CatalogSpec {
+  return {
+    permissions: appAclConfig.permissions,
+    roles: appAclConfig.roles.map((role) => ({
+      uuid: role.uuid,
+      slug: role.slug,
+      scopeType: 'app',
+      name: role.name,
+      description: role.description,
+      rank: role.rank,
+      permissions: role.permissions === '*' ? appPermissionSlugs() : role.permissions,
+    })),
+  }
+}
+
+export default appAclConfig

package/build/stubs/config/authorization.stub

@@ -0,0 +1,74 @@
+{{{
+  exports({ to: app.configPath('authorization.ts') })
+}}}
+import env from '#start/env'
+import { defineConfig, DatabaseAuthorizationDriver } from '@jantstack/adonis-authz'
+import type { AuthzWriteEvent, ScopeRef } from '@jantstack/adonis-authz'
+
+/**
+ * Holders de tu aplicación: morph name (`@MorphMap` del modelo) → tipo del
+ * modelo FGA. Solo lo usa el driver `openfga` y sus comandos.
+ *
+ * ⚠️ Cambiar este mapa cambia el authorization model: hay que re-provisionar
+ * el store (`node ace openfga:provision`) y reimportar los hechos.
+ */
+export const holderTypes = {
+  users: 'user',
+}
+
+/**
+ * Jerarquía de scopes de tu dominio. El motor solo conoce la raíz (`app`);
+ * si tienes niveles propios (organizaciones, proyectos, sedes…), devuelve
+ * aquí sus ancestros del más cercano a la raíz.
+ *
+ *   organization → [APP_SCOPE]
+ *   unit         → [padres…, su organization, APP_SCOPE]
+ */
+async function resolveScopeAncestors(scope: ScopeRef): Promise<ScopeRef[]> {
+  if (scope.type === 'app') return []
+  return [{ type: 'app', uuid: null }]
+}
+
+/**
+ * Side-effects de cada escritura del motor (grant/revoke/deny). El sitio
+ * natural para auditar. Debe ser best-effort: no lances desde aquí.
+ */
+async function onAuthzWrite(_event: AuthzWriteEvent) {}
+
+export default defineConfig({
+  default: env.get('AUTHZ_DRIVER', 'database'),
+
+  holderTypes,
+
+  openfga: {
+    url: env.get('OPENFGA_URL'),
+    storeId: env.get('OPENFGA_STORE_ID'),
+    modelId: env.get('OPENFGA_MODEL_ID'),
+  },
+
+  drivers: {
+    database: () => new DatabaseAuthorizationDriver({ resolveAncestors: resolveScopeAncestors }),
+
+    /**
+     * Backend externo opcional. Levanta el servidor y provisiona con
+     * `node ace openfga:provision`; migra los hechos con `openfga:import`.
+     */
+    openfga: async () => {
+      const { OpenFgaAuthorizationDriver } = await import('@jantstack/adonis-authz')
+      const apiUrl = env.get('OPENFGA_URL')
+      const storeId = env.get('OPENFGA_STORE_ID')
+      if (!apiUrl || !storeId) {
+        throw new Error('AUTHZ_DRIVER=openfga requiere OPENFGA_URL y OPENFGA_STORE_ID')
+      }
+      return new OpenFgaAuthorizationDriver({
+        apiUrl,
+        storeId,
+        modelId: env.get('OPENFGA_MODEL_ID'),
+        resolveAncestors: resolveScopeAncestors,
+        holderTypes,
+      })
+    },
+  },
+
+  hooks: { onWrite: onAuthzWrite },
+})

package/build/stubs/main.d.ts

@@ -0,0 +1,3 @@
+/** Raíz de los stubs publicables por `configure`. */
+export declare const stubsRoot: string;
+//# sourceMappingURL=main.d.ts.map

package/build/stubs/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../stubs/main.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,eAAO,MAAM,SAAS,QAAsB,CAAA"}

package/build/stubs/main.js

@@ -0,0 +1,3 @@
+/** Raíz de los stubs publicables por `configure`. */
+export const stubsRoot = import.meta.dirname;
+//# sourceMappingURL=main.js.map

package/build/stubs/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../stubs/main.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAA"}