@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/modules/auth/auth.utils.d.ts.map

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

package/dist/src/modules/auth/auth.utils.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveOrganizationAndTeam = getActiveOrganizationAndTeam;
+exports.createOrganizationAndTeam = createOrganizationAndTeam;
+const tslib_1 = require("tslib");
+const drizzle_orm_1 = require("drizzle-orm");
+const uuid_1 = require("uuid");
+const auth = tslib_1.__importStar(require("#modules/auth/auth.db"));
+const schema = { ...auth };
+async function getActiveOrganizationAndTeam(orm, schema, userId) {
+    let organizationId;
+    let teamId;
+    let organizationRole;
+    let teamRole;
+    const [lastSession] = await orm
+        .select({
+        activeOrganizationId: schema.sessions.activeOrganizationId,
+        activeTeamId: schema.sessions.activeTeamId,
+        activeOrganizationRole: schema.sessions.activeOrganizationRole,
+        activeTeamRole: schema.sessions.activeTeamRole,
+    })
+        .from(schema.sessions)
+        .where((0, drizzle_orm_1.eq)(schema.sessions.userId, userId))
+        .orderBy((0, drizzle_orm_1.desc)(schema.sessions.createdAt))
+        .limit(1);
+    if (lastSession) {
+        organizationId = lastSession.activeOrganizationId ?? undefined;
+        teamId = lastSession.activeTeamId ?? undefined;
+        organizationRole = lastSession.activeOrganizationRole ?? undefined;
+        teamRole = lastSession.activeTeamRole ?? undefined;
+    }
+    if (!organizationId || !organizationRole) {
+        const [member] = await orm
+            .select({ organizationId: schema.members.organizationId, role: schema.members.role })
+            .from(schema.members)
+            .orderBy((0, drizzle_orm_1.desc)(schema.members.createdAt))
+            .where((0, drizzle_orm_1.eq)(schema.members.userId, userId))
+            .limit(1);
+        organizationId = member?.organizationId;
+        organizationRole = member?.role;
+    }
+    if (!teamId || !teamRole) {
+        const [teamMember] = await orm
+            .select({ teamId: schema.teamMembers.teamId, role: schema.teamMembers.role })
+            .from(schema.teamMembers)
+            .orderBy((0, drizzle_orm_1.desc)(schema.teamMembers.createdAt))
+            .where((0, drizzle_orm_1.eq)(schema.teamMembers.userId, userId))
+            .limit(1);
+        teamId = teamMember?.teamId;
+        teamRole = teamMember?.role;
+    }
+    return { organizationId, teamId, organizationRole, teamRole };
+}
+async function createOrganizationAndTeam(orm, schema, user) {
+    const organizationId = (0, uuid_1.v4)();
+    await orm.transaction(async (tx) => {
+        const [organization] = await tx
+            .insert(schema.organizations)
+            .values({
+            id: organizationId,
+            name: organizationId,
+            slug: organizationId,
+        })
+            .returning();
+        if (!organization)
+            throw new Error("createOrganizationAndTeam: Failed to create organization");
+        const [member] = await tx
+            .insert(schema.members)
+            .values({
+            userId: user.id,
+            organizationId: organization.id,
+            role: "owner",
+        })
+            .returning();
+        if (!member)
+            throw new Error("createOrganizationAndTeam: Failed to create member");
+        const [team] = await tx
+            .insert(schema.teams)
+            .values({
+            name: organization.id,
+            organizationId: organization.id,
+        })
+            .returning();
+        if (!team)
+            throw new Error("createOrganizationAndTeam: Failed to create team");
+        const [teamMember] = await tx
+            .insert(schema.teamMembers)
+            .values({
+            userId: user.id,
+            teamId: team.id,
+            role: "owner",
+        })
+            .returning();
+        if (!teamMember)
+            throw new Error("createOrganizationAndTeam: Failed to create team member");
+    });
+}

package/dist/src/modules/base/base.abstract.d.ts

@@ -0,0 +1,19 @@
+import type { TRPC_ERROR_CODE_KEY } from "@trpc/server";
+import type { ServerResult, ServerResultAsync } from "#modules/base/base.dto";
+import type { ServerErrorLayer } from "#modules/base/base.types";
+import { ServerError } from "#utils/errors";
+import { logger } from "#utils/logger";
+export declare abstract class Base {
+    layer: ServerErrorLayer;
+    logger: ReturnType<typeof logger.child>;
+    constructor(layer: ServerErrorLayer);
+    error(code: TRPC_ERROR_CODE_KEY, message?: string, { cause, clientMessage, log, }?: {
+        cause?: unknown;
+        clientMessage?: string;
+        log?: boolean;
+    }): import("neverthrow").Err<never, ServerError>;
+    handleUnknownError(error: unknown): ServerError;
+    throwable<T>(fn: () => ServerResult<T>): ServerResult<T>;
+    throwableAsync<T>(fn: () => ServerResultAsync<T>): ServerResultAsync<T>;
+}
+//# sourceMappingURL=base.abstract.d.ts.map

package/dist/src/modules/base/base.abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.abstract.d.ts","sourceRoot":"","sources":["../../../../src/modules/base/base.abstract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAe,WAAW,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,8BAAsB,IAAI;IACjB,KAAK,EAAE,gBAAgB,CAAC;IACxB,MAAM,EAAE,UAAU,CAAC,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;gBAEnC,KAAK,EAAE,gBAAgB;IAKnC,KAAK,CACH,IAAI,EAAE,mBAAmB,EACzB,OAAO,CAAC,EAAE,MAAM,EAChB,EACE,KAAK,EACL,aAAa,EACb,GAA4C,GAC7C,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAO;IAgBpE,kBAAkB,CAAC,KAAK,EAAE,OAAO;IAOjC,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAQlD,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC;CAO9E"}

package/dist/src/modules/base/base.abstract.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("#utils/errors");
+const logger_1 = require("#utils/logger");
+class Base {
+    layer;
+    logger;
+    constructor(layer) {
+        this.layer = layer;
+        this.logger = logger_1.logger.child({ layer: this.layer, layerName: this.constructor.name });
+    }
+    error(code, message, { cause, clientMessage, log = process.env.NODE_ENV === "development", } = {}) {
+        const serverError = new errors_1.ServerError({
+            code,
+            layer: this.layer,
+            layerName: this.constructor.name,
+            message,
+            clientMessage,
+            cause,
+            captureBoundary: true,
+        });
+        if (serverError.is5xxError())
+            (0, errors_1.reportError)(serverError);
+        if (log)
+            logger_1.logger.error(serverError);
+        return (0, neverthrow_1.err)(serverError);
+    }
+    handleUnknownError(error) {
+        return errors_1.ServerError.fromUnknown("INTERNAL_SERVER_ERROR", error, {
+            layer: this.layer,
+            layerName: this.constructor.name,
+        });
+    }
+    throwable(fn) {
+        try {
+            return fn();
+        }
+        catch (error) {
+            return (0, neverthrow_1.err)(this.handleUnknownError(error));
+        }
+    }
+    async throwableAsync(fn) {
+        try {
+            return fn();
+        }
+        catch (error) {
+            return (0, neverthrow_1.err)(this.handleUnknownError(error));
+        }
+    }
+}
+exports.Base = Base;

package/dist/src/modules/base/base.dto.d.ts

@@ -0,0 +1,70 @@
+import { getTableColumns, type InferSelectModel, type Table } from "drizzle-orm";
+import type { Result } from "neverthrow";
+import { z } from "zod";
+import type { ServerError } from "#utils/errors";
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type StringKeys<T> = Extract<keyof T, string>;
+export type ServerResult<T> = Result<T, ServerError>;
+export type ServerResultAsync<T> = Promise<ServerResult<T>>;
+export declare const createTableSelectSchema: <T extends Table>(table: T) => import("drizzle-zod").BuildSchema<"select", T["_"]["columns"], undefined, undefined>;
+export type ExtractColumnTypes<T extends Table, C extends Record<string, unknown>> = Simplify<Pick<InferSelectModel<T>, Extract<keyof C, keyof InferSelectModel<T>>>>;
+export declare function toZodFilter<const T extends readonly string[]>(array: T): Record<T[number], true>;
+export declare function pickSchema<Shape extends z.ZodRawShape, const Keys extends readonly StringKeys<Shape>[]>(schema: z.ZodObject<Shape>, keys: Keys): z.ZodObject<Pick<Shape, Keys[number]>>;
+export declare function pickTableSchema<T extends Table, K extends keyof InferSelectModel<T>>(table: T, columns: readonly K[]): z.ZodObject<Pick<(T["_"]["columns"] extends infer T_2 extends Record<string, any> ? { [K_2 in keyof T_2 as import("drizzle-zod").ColumnIsGeneratedAlwaysAs<T["_"]["columns"][K_2]> extends true ? K_2 : K_2]: T_2[K_2] extends infer TColumn extends import("drizzle-orm").Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object> ? (TRefinements extends object ? TRefinements[K_2] extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | ((schema: any) => any) ? true : false : false) extends true ? import("drizzle-orm").Assume<TRefinements[K_2 & keyof TRefinements] extends infer T_3 ? T_3 extends TRefinements[K_2 & keyof TRefinements] ? T_3 extends (schema: any) => z.ZodType ? (TColumn["_"]["notNull"] extends true ? ReturnType<T_3> : z.ZodNullable<ReturnType<T_3>>) extends infer TSchema extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? TType extends "update" ? z.ZodOptional<TSchema> : TSchema : z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> : T_3 : never : never, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>> : import("drizzle-zod").HandleColumn<TType, TColumn, TCoerce> : T_2[K_2] extends infer TObject extends Table<import("drizzle-orm").TableConfig<import("drizzle-orm").Column<any, object, object>>> | import("drizzle-orm").View<string, boolean, import("drizzle-orm").ColumnsSelection> | import("drizzle-orm").SelectedFieldsFlat<import("drizzle-orm").Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>> ? import("drizzle-zod").BuildSchema<TType, import("drizzle-zod").GetSelection<TObject>, TRefinements extends object ? TRefinements[K_2 & keyof TRefinements] : undefined, TCoerce> : z.ZodAny; } : never) extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never, K>, z.core.$strip>;
+export declare function omitSchema<Shape extends z.ZodRawShape, const Keys extends readonly StringKeys<Shape>[]>(schema: z.ZodObject<Shape>, keys: Keys): z.ZodObject<Omit<Shape, Keys[number]>>;
+export declare function omitTableSchema<T extends Table, K extends keyof InferSelectModel<T>>(table: T, columns: readonly K[]): z.ZodObject<Omit<(T["_"]["columns"] extends infer T_2 extends Record<string, any> ? { [K_2 in keyof T_2 as import("drizzle-zod").ColumnIsGeneratedAlwaysAs<T["_"]["columns"][K_2]> extends true ? K_2 : K_2]: T_2[K_2] extends infer TColumn extends import("drizzle-orm").Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object> ? (TRefinements extends object ? TRefinements[K_2] extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | ((schema: any) => any) ? true : false : false) extends true ? import("drizzle-orm").Assume<TRefinements[K_2 & keyof TRefinements] extends infer T_3 ? T_3 extends TRefinements[K_2 & keyof TRefinements] ? T_3 extends (schema: any) => z.ZodType ? (TColumn["_"]["notNull"] extends true ? ReturnType<T_3> : z.ZodNullable<ReturnType<T_3>>) extends infer TSchema extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? TType extends "update" ? z.ZodOptional<TSchema> : TSchema : z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> : T_3 : never : never, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>> : import("drizzle-zod").HandleColumn<TType, TColumn, TCoerce> : T_2[K_2] extends infer TObject extends Table<import("drizzle-orm").TableConfig<import("drizzle-orm").Column<any, object, object>>> | import("drizzle-orm").View<string, boolean, import("drizzle-orm").ColumnsSelection> | import("drizzle-orm").SelectedFieldsFlat<import("drizzle-orm").Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>> ? import("drizzle-zod").BuildSchema<TType, import("drizzle-zod").GetSelection<TObject>, TRefinements extends object ? TRefinements[K_2 & keyof TRefinements] : undefined, TCoerce> : z.ZodAny; } : never) extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never, K>, z.core.$strip>;
+export { getTableColumns };
+export declare function pickColumns<T extends Table, Shape extends z.ZodRawShape>(table: T, schema: z.ZodObject<Shape>): Pick<ReturnType<typeof getTableColumns<T>>, Extract<keyof Shape, string>>;
+export declare function pickTableColumns<T extends Table, K extends keyof InferSelectModel<T>>(table: T, columns: readonly K[]): Pick<ReturnType<typeof getTableColumns<T>>, K>;
+export declare function omitTableColumns<T extends Table, K extends keyof InferSelectModel<T>>(table: T, columns: readonly K[]): Omit<ReturnType<typeof getTableColumns<T>>, K>;
+export declare function createSelectDTO<T extends Table>(table: T): {
+    columns: ReturnType<typeof getTableColumns<T>>;
+    schema: ReturnType<typeof createTableSelectSchema<T>>;
+};
+export declare function createSelectDTO<T extends Table, K extends Extract<keyof InferSelectModel<T>, string>>(table: T, partial: {
+    omit: readonly K[];
+}): {
+    columns: ReturnType<typeof omitTableColumns<T, K>>;
+    schema: ReturnType<typeof omitTableSchema<T, K>>;
+};
+export declare function createSelectDTO<T extends Table, K extends Extract<keyof InferSelectModel<T>, string>>(table: T, partial: {
+    pick: readonly K[];
+}): {
+    columns: ReturnType<typeof pickTableColumns<T, K>>;
+    schema: ReturnType<typeof pickTableSchema<T, K>>;
+};
+export declare function createSelectUtils<T extends Record<string, {
+    columns: unknown;
+    schema: z.ZodTypeAny;
+}>, S extends z.ZodTypeAny>(dtos: T, output: S, transformer: (rows: Array<{
+    [K in keyof T]: z.infer<T[K]["schema"]>;
+}>) => z.infer<S>): {
+    select: {
+        [K in keyof T]: T[K]["columns"];
+    };
+    output: S;
+    transformer: (rows: Array<{
+        [K in keyof T]: z.infer<T[K]["schema"]>;
+    }>) => z.infer<S>;
+};
+export declare const uuidOutput: z.ZodObject<{
+    id: z.ZodUUID;
+}, z.core.$strip>;
+export declare const uuidManyOutput: z.ZodObject<{
+    ids: z.ZodArray<z.ZodUUID>;
+}, z.core.$strip>;
+export declare const scheduleOutput: z.ZodObject<{
+    jobId: z.ZodString;
+}, z.core.$strip>;
+export declare const scheduleManyOutput: z.ZodObject<{
+    jobIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const deleteOutput: z.ZodObject<{
+    id: z.ZodUUID;
+}, z.core.$strip>;
+export declare const deleteManyOutput: z.ZodObject<{
+    ids: z.ZodArray<z.ZodUUID>;
+}, z.core.$strip>;
+//# sourceMappingURL=base.dto.d.ts.map

package/dist/src/modules/base/base.dto.d.ts.map

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

package/dist/src/modules/base/base.dto.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteManyOutput = exports.deleteOutput = exports.scheduleManyOutput = exports.scheduleOutput = exports.uuidManyOutput = exports.uuidOutput = exports.getTableColumns = exports.createTableSelectSchema = void 0;
+exports.toZodFilter = toZodFilter;
+exports.pickSchema = pickSchema;
+exports.pickTableSchema = pickTableSchema;
+exports.omitSchema = omitSchema;
+exports.omitTableSchema = omitTableSchema;
+exports.pickColumns = pickColumns;
+exports.pickTableColumns = pickTableColumns;
+exports.omitTableColumns = omitTableColumns;
+exports.createSelectDTO = createSelectDTO;
+exports.createSelectUtils = createSelectUtils;
+const drizzle_orm_1 = require("drizzle-orm");
+Object.defineProperty(exports, "getTableColumns", { enumerable: true, get: function () { return drizzle_orm_1.getTableColumns; } });
+const drizzle_zod_1 = require("drizzle-zod");
+const zod_1 = require("zod");
+// Wrapper to force the drizzle-zod overload to the Table version
+const createTableSelectSchema = (table) => (0, drizzle_zod_1.createSelectSchema)(table);
+exports.createTableSelectSchema = createTableSelectSchema;
+function toZodFilter(array) {
+    return array.reduce((acc, column) => {
+        acc[column] = true;
+        return acc;
+    }, {});
+}
+function pickSchema(schema, keys) {
+    const mask = {};
+    for (const k of keys) {
+        mask[k] = true;
+    }
+    return schema.pick(mask);
+}
+function pickTableSchema(table, columns) {
+    return pickSchema((0, drizzle_zod_1.createSelectSchema)(table), columns);
+}
+function omitSchema(schema, keys) {
+    const mask = {};
+    for (const k of keys) {
+        mask[k] = true;
+    }
+    return schema.omit(mask);
+}
+function omitTableSchema(table, columns) {
+    return omitSchema((0, drizzle_zod_1.createSelectSchema)(table), columns);
+}
+function pickColumns(table, schema) {
+    const allColumns = (0, drizzle_orm_1.getTableColumns)(table);
+    const schemaKeys = Object.keys(schema.shape);
+    const result = {};
+    for (const key of schemaKeys) {
+        if (key in allColumns) {
+            result[key] = allColumns[key];
+        }
+    }
+    return result;
+}
+function pickTableColumns(table, columns) {
+    const allColumns = (0, drizzle_orm_1.getTableColumns)(table);
+    const result = {};
+    for (const key of columns) {
+        if (key in allColumns) {
+            result[key] = allColumns[key];
+        }
+    }
+    return result;
+}
+function omitTableColumns(table, columns) {
+    const allColumns = (0, drizzle_orm_1.getTableColumns)(table);
+    const columnsToOmit = new Set(columns);
+    const filteredEntries = Object.entries(allColumns).filter(([key]) => !columnsToOmit.has(key));
+    return Object.fromEntries(filteredEntries);
+}
+// Implementation
+function createSelectDTO(table, partial) {
+    if (partial) {
+        if ("omit" in partial && partial.omit) {
+            return {
+                columns: omitTableColumns(table, partial.omit),
+                schema: omitTableSchema(table, partial.omit),
+            };
+        }
+        if ("pick" in partial && partial.pick) {
+            return {
+                columns: pickTableColumns(table, partial.pick),
+                schema: pickTableSchema(table, partial.pick),
+            };
+        }
+    }
+    return { columns: (0, drizzle_orm_1.getTableColumns)(table), schema: (0, exports.createTableSelectSchema)(table) };
+}
+function createSelectUtils(dtos, output, transformer) {
+    return {
+        select: Object.fromEntries(Object.entries(dtos).map(([key, dto]) => [key, dto.columns])),
+        output,
+        transformer,
+    };
+}
+exports.uuidOutput = zod_1.z.object({
+    id: zod_1.z.uuid(),
+});
+exports.uuidManyOutput = zod_1.z.object({
+    ids: zod_1.z.array(zod_1.z.uuid()),
+});
+exports.scheduleOutput = zod_1.z.object({
+    jobId: zod_1.z.string(),
+});
+exports.scheduleManyOutput = zod_1.z.object({
+    jobIds: zod_1.z.array(zod_1.z.string()),
+});
+exports.deleteOutput = exports.uuidOutput;
+exports.deleteManyOutput = exports.uuidManyOutput;

package/dist/src/modules/base/base.grants.d.ts

@@ -0,0 +1,29 @@
+import type { Session, User } from "#modules/auth/auth.lib";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+type Level = "user" | "team" | "organization";
+type Access = "all" | "own";
+export type Entity = Partial<{
+    userId: string | null;
+    teamId: string | null;
+    organizationId: string | null;
+}>;
+export type Grant = {
+    level: Level;
+    role: string;
+    action: string;
+    resource: string;
+    access: Access;
+    attributes?: string[];
+};
+export type NestedGrants = Record<string, Partial<Record<Level, Record<string, Record<string, Access>>>>>;
+export type ResourceGrant = Omit<Grant, "resource">;
+export type ResourceActionGrant = Omit<ResourceGrant, "action">;
+export declare function flattenNestedGrants(nestedGrants: NestedGrants): Grant[];
+interface PermissionContext {
+    session: Session;
+    user: User;
+}
+export declare function checkPermissionSync<T extends Entity>(ctx: PermissionContext, grants: ResourceActionGrant[], entities?: T | T[]): boolean;
+export declare function checkPermissionAsync<T extends Entity>(ctx: PermissionContext, grants: ResourceActionGrant[], getEntities: () => ServerResultAsync<T | T[] | undefined>): ServerResultAsync<boolean>;
+export {};
+//# sourceMappingURL=base.grants.d.ts.map

package/dist/src/modules/base/base.grants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.grants.d.ts","sourceRoot":"","sources":["../../../../src/modules/base/base.grants.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,KAAK,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,cAAc,CAAC;AAC9C,KAAK,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;AAE5B,MAAM,MAAM,MAAM,GAAG,OAAO,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG;IAClB,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,MAAM,CAC/B,MAAM,EACN,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAC/D,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;AAEpD,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;AAEhE,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,YAAY,GAAG,KAAK,EAAE,CAgBvE;AAcD,UAAU,iBAAiB;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;CACZ;AAoFD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,EAClD,GAAG,EAAE,iBAAiB,EACtB,MAAM,EAAE,mBAAmB,EAAE,EAC7B,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,GACjB,OAAO,CAmBT;AAED,wBAAsB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EACzD,GAAG,EAAE,iBAAiB,EACtB,MAAM,EAAE,mBAAmB,EAAE,EAC7B,WAAW,EAAE,MAAM,iBAAiB,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,CAAC,GACxD,iBAAiB,CAAC,OAAO,CAAC,CAqB5B"}

package/dist/src/modules/base/base.grants.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenNestedGrants = flattenNestedGrants;
+exports.checkPermissionSync = checkPermissionSync;
+exports.checkPermissionAsync = checkPermissionAsync;
+const neverthrow_1 = require("neverthrow");
+function flattenNestedGrants(nestedGrants) {
+    return Object.entries(nestedGrants).flatMap(([resource, levels]) => {
+        return Object.entries(levels).flatMap(([level, roles]) => {
+            return Object.entries(roles).flatMap(([role, actions]) => {
+                return Object.entries(actions).map(([action, access]) => {
+                    return {
+                        resource,
+                        level: level,
+                        role,
+                        action,
+                        access,
+                    };
+                });
+            });
+        });
+    });
+}
+function checkOwnership(entityField, contextValue, entities) {
+    if (!contextValue)
+        return false;
+    if (!entities)
+        return false;
+    return Array.isArray(entities)
+        ? entities.every((e) => e[entityField] === contextValue)
+        : entities[entityField] === contextValue;
+}
+// Level priority: user -> team -> organization (bottom-up)
+const LEVEL_PRIORITY = ["user", "team", "organization"];
+function getRoleForLevel(level, ctx) {
+    switch (level) {
+        case "user":
+            return ctx.userRole;
+        case "team":
+            return ctx.teamRole;
+        case "organization":
+            return ctx.organizationRole;
+    }
+}
+function getContextValueForLevel(level, ctx) {
+    switch (level) {
+        case "user":
+            return ctx.userId;
+        case "team":
+            return ctx.teamId;
+        case "organization":
+            return ctx.organizationId;
+    }
+}
+function getOwnershipFieldForLevel(level) {
+    switch (level) {
+        case "user":
+            return "userId";
+        case "team":
+            return "teamId";
+        case "organization":
+            return "organizationId";
+    }
+}
+function hasAllAccess(grants, roles) {
+    for (const level of LEVEL_PRIORITY) {
+        for (const grant of grants) {
+            if (grant.level !== level)
+                continue;
+            if (grant.access !== "all")
+                continue;
+            if (grant.role === getRoleForLevel(level, roles))
+                return true;
+        }
+    }
+    return false;
+}
+function checkOwnAccess(grants, roles, contextValues, entities) {
+    for (const level of LEVEL_PRIORITY) {
+        for (const grant of grants) {
+            if (grant.level !== level)
+                continue;
+            if (grant.access !== "own")
+                continue;
+            if (grant.role !== getRoleForLevel(level, roles))
+                continue;
+            const ownershipField = getOwnershipFieldForLevel(level);
+            const contextValue = getContextValueForLevel(level, contextValues);
+            if (checkOwnership(ownershipField, contextValue, entities))
+                return true;
+        }
+    }
+    return false;
+}
+function checkPermissionSync(ctx, grants, entities) {
+    if (!grants || grants.length === 0)
+        return false;
+    const { id: userId, role: userRole } = ctx.user;
+    const { activeOrganizationRole: organizationRole, activeTeamRole: teamRole, activeOrganizationId: organizationId, activeTeamId: teamId, } = ctx.session;
+    const roles = { userRole, teamRole, organizationRole };
+    const contextValues = { userId, teamId, organizationId };
+    // Pass 1: Check for "all" access first (no ownership check needed)
+    if (hasAllAccess(grants, roles))
+        return true;
+    // Pass 2: Check "own" access with ownership validation
+    return checkOwnAccess(grants, roles, contextValues, entities);
+}
+async function checkPermissionAsync(ctx, grants, getEntities) {
+    if (!grants || grants.length === 0)
+        return (0, neverthrow_1.ok)(false);
+    const { id: userId, role: userRole } = ctx.user;
+    const { activeOrganizationRole: organizationRole, activeTeamRole: teamRole, activeOrganizationId: organizationId, activeTeamId: teamId, } = ctx.session;
+    const roles = { userRole, teamRole, organizationRole };
+    const contextValues = { userId, teamId, organizationId };
+    // Pass 1: Check for "all" access first (no entity fetch needed)
+    if (hasAllAccess(grants, roles))
+        return (0, neverthrow_1.ok)(true);
+    // Pass 2: Only fetch entities if we need to check ownership
+    const entities = await getEntities();
+    if (entities.isErr())
+        return (0, neverthrow_1.err)(entities.error);
+    return (0, neverthrow_1.ok)(checkOwnAccess(grants, roles, contextValues, entities.value));
+}

package/dist/src/modules/base/base.grants.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=base.grants.test.d.ts.map

package/dist/src/modules/base/base.grants.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.grants.test.d.ts","sourceRoot":"","sources":["../../../../src/modules/base/base.grants.test.ts"],"names":[],"mappings":""}