@nmnmcc/ability 0.2.0 → 0.3.0

package/dist/internal/ability.js

@@ -1,550 +0,0 @@
-import { cloneSerializable } from "./serializable.js";
-import { createMongoAbility, mongoQueryMatcher } from "@casl/ability";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Equal from "effect/Equal";
-import * as Formatter from "effect/Formatter";
-import { dual } from "effect/Function";
-import * as Hash from "effect/Hash";
-import * as Inspectable from "effect/Inspectable";
-import * as Pipeable from "effect/Pipeable";
-import * as Predicate from "effect/Predicate";
-//#region src/internal/ability.ts
-/**
-* @since 0.1.0
-*/
-/**
-* @internal
-*/
-const TypeId = Symbol.for("@nmnmcc/ability/Ability");
-/**
-* @internal
-*/
-const SubjectTypeId = Symbol.for("@nmnmcc/ability/Subject");
-/**
-* @internal
-*/
-const RuleTypeId = Symbol.for("@nmnmcc/ability/Rule");
-const anyAction = "manage";
-const anySubject = "all";
-const CaslStateTypeId = Symbol.for("@nmnmcc/ability/Ability/caslState");
-/**
-* @since 0.1.0
-* @category Errors
-*/
-var AuthorizationError = class extends Data.TaggedError("AuthorizationError") {};
-/**
-* @since 0.1.0
-* @category Errors
-*/
-var ConditionError = class extends Data.TaggedError("ConditionError") {};
-/**
-* @since 0.1.0
-* @category Errors
-*/
-var RawRuleError = class extends Data.TaggedError("RawRuleError") {};
-/**
-* @since 0.1.0
-* @category Errors
-*/
-var SubjectDetectionError = class extends Data.TaggedError("SubjectDetectionError") {};
-/**
-* @since 0.1.0
-* @category Errors
-*/
-var AliasError = class extends Data.TaggedError("AliasError") {};
-/**
-* @since 0.1.0
-* @category Errors
-*/
-var QueryGenerationError = class extends Data.TaggedError("QueryGenerationError") {};
-const copyArray = (value) => Object.freeze(Array.from(value));
-const wrapArray = (value) => Array.isArray(value) ? value : [value];
-const normalizeArray = (value) => Array.isArray(value) ? copyArray(value) : value;
-const unique = (values) => Object.freeze(Array.from(new Set(values)));
-const aliasError = (reason, action) => {
-	const error = { reason };
-	if (action !== void 0) error.action = action;
-	return new AliasError(error);
-};
-const normalizeActionAliases = (aliases) => {
-	if (aliases === void 0) return Object.freeze({});
-	const normalized = {};
-	for (const action of Object.keys(aliases)) {
-		if (action === anyAction) throw aliasError(`Cannot use "${anyAction}" as an action alias`, action);
-		const targets = wrapArray(aliases[action]);
-		if (targets.length === 0) throw aliasError("Action alias cannot target an empty action list", action);
-		for (const target of targets) if (target === anyAction) throw aliasError(`Cannot create an alias to reserved action "${anyAction}"`, action);
-		normalized[action] = copyArray(targets);
-	}
-	const visiting = /* @__PURE__ */ new Set();
-	const visited = /* @__PURE__ */ new Set();
-	const visit = (action, path) => {
-		if (visited.has(action)) return;
-		if (visiting.has(action)) throw aliasError(`Detected cyclic action alias: ${[...path, action].join(" -> ")}`, action);
-		const targets = normalized[action];
-		if (targets === void 0) return;
-		visiting.add(action);
-		for (const target of targets) {
-			if (target === action) throw aliasError(`Action alias "${action}" cannot reference itself`, action);
-			visit(target, [...path, action]);
-		}
-		visiting.delete(action);
-		visited.add(action);
-	};
-	for (const action of Object.keys(normalized)) visit(action, []);
-	return Object.freeze(normalized);
-};
-const expandAction = (aliases, action, output) => {
-	if (output.has(action)) return;
-	output.add(action);
-	const targets = aliases[action];
-	if (targets === void 0) return;
-	for (const target of targets) expandAction(aliases, target, output);
-};
-/**
-* @internal
-*/
-const createAliasResolver = (aliases) => {
-	const normalized = normalizeActionAliases(aliases);
-	return (action) => {
-		const actions = /* @__PURE__ */ new Set();
-		for (const value of wrapArray(action)) expandAction(normalized, value, actions);
-		return unique(actions);
-	};
-};
-function* ruleIterator(rule) {
-	return yield rule;
-}
-const inspectableToString = function() {
-	return Formatter.format(this.toJSON(), {
-		ignoreToString: true,
-		space: 2
-	});
-};
-const inspectableNode = function() {
-	return this.toJSON();
-};
-const ruleHashInput = (rule) => ({
-	_tag: rule._tag,
-	action: rule.action,
-	subject: rule.subject,
-	fields: rule.fields,
-	conditions: rule.conditions,
-	reason: rule.reason
-});
-const RuleProto = {
-	...Pipeable.Prototype,
-	[RuleTypeId]: RuleTypeId,
-	[Symbol.iterator]() {
-		return ruleIterator(this);
-	},
-	asEffect() {
-		return Effect.succeed(this);
-	},
-	[Equal.symbol](that) {
-		return isRule(that) && Equal.equals(ruleHashInput(this), ruleHashInput(that));
-	},
-	[Hash.symbol]() {
-		return Hash.structure(ruleHashInput(this));
-	},
-	toString: inspectableToString,
-	toJSON() {
-		const json = {
-			_tag: this._tag,
-			action: this.action,
-			subject: this.subject
-		};
-		if (this.fields !== void 0) json.fields = this.fields;
-		if (this.conditions !== void 0) json.conditions = this.conditions;
-		if (this.reason !== void 0) json.reason = this.reason;
-		return json;
-	},
-	[Inspectable.NodeInspectSymbol]: inspectableNode
-};
-const AbilityProto = {
-	...Pipeable.Prototype,
-	[TypeId]: TypeId,
-	[Equal.symbol](that) {
-		return isAbility(that) && Equal.equals(this.rules, that.rules) && Equal.equals(this.options, that.options);
-	},
-	[Hash.symbol]() {
-		return Hash.structure({
-			rules: this.rules,
-			options: this.options
-		});
-	},
-	toString: inspectableToString,
-	toJSON() {
-		return {
-			_id: "Ability",
-			rules: this.rules,
-			options: this.options
-		};
-	},
-	[Inspectable.NodeInspectSymbol]: inspectableNode
-};
-const SubjectProto = {
-	...Pipeable.Prototype,
-	[SubjectTypeId]: SubjectTypeId,
-	[Equal.symbol](that) {
-		return isSubject(that) && this.subject === that.subject && Equal.equals(this.value, that.value);
-	},
-	[Hash.symbol]() {
-		return Hash.structure({
-			subject: this.subject,
-			value: this.value
-		});
-	},
-	toString: inspectableToString,
-	toJSON() {
-		return {
-			_id: "Subject",
-			subject: this.subject,
-			value: this.value
-		};
-	},
-	[Inspectable.NodeInspectSymbol]: inspectableNode
-};
-const freezeOptions = (options) => {
-	const copy = {};
-	if (options?.detectSubjectType !== void 0) copy.detectSubjectType = options.detectSubjectType;
-	if (options?.actionAliases !== void 0) copy.actionAliases = normalizeActionAliases(options.actionAliases);
-	return Object.freeze(copy);
-};
-const freezeRule = (rule) => {
-	const copy = Object.create(RuleProto);
-	copy._tag = rule._tag;
-	copy.action = normalizeArray(rule.action);
-	copy.subject = normalizeArray(rule.subject);
-	if (rule.fields !== void 0) copy.fields = copyArray(rule.fields);
-	if (rule.conditions !== void 0) copy.conditions = cloneSerializable(rule.conditions);
-	if (rule.reason !== void 0) copy.reason = rule.reason;
-	return Object.freeze(copy);
-};
-const toCaslRawRule = (rule) => {
-	const raw = {
-		action: cloneSerializable(rule.action),
-		subject: cloneSerializable(rule.subject)
-	};
-	if (rule.fields !== void 0) raw.fields = cloneSerializable(rule.fields);
-	if (rule.conditions !== void 0) raw.conditions = cloneSerializable(rule.conditions);
-	if (rule._tag === "Deny") raw.inverted = true;
-	if (rule.reason !== void 0) raw.reason = rule.reason;
-	return raw;
-};
-const buildCaslState = (rules, aliases) => {
-	const resolver = createAliasResolver(aliases ?? {});
-	const rulesByRawRule = /* @__PURE__ */ new WeakMap();
-	const indexByRule = /* @__PURE__ */ new Map();
-	const rawRules = [];
-	let ruleIndex = 0;
-	for (const rule of rules) {
-		const rawRule = toCaslRawRule(rule);
-		rawRules.push(rawRule);
-		rulesByRawRule.set(rawRule, rule);
-		indexByRule.set(rule, ruleIndex);
-		ruleIndex = ruleIndex + 1;
-	}
-	return Object.freeze({
-		ability: createMongoAbility(rawRules, {
-			anyAction,
-			anySubjectType: anySubject,
-			resolveAction: (action) => resolver(action)
-		}),
-		rulesByRawRule,
-		indexByRule: Object.freeze(indexByRule)
-	});
-};
-const getCaslState = (self) => self[CaslStateTypeId];
-/**
-* @internal
-*/
-const make = (rules, options) => {
-	const self = Object.create(AbilityProto);
-	self.rules = Object.freeze(Array.from(rules, freezeRule));
-	self.options = freezeOptions(options);
-	self[CaslStateTypeId] = buildCaslState(self.rules, self.options.actionAliases);
-	return Object.freeze(self);
-};
-const makeRule = (kind, action, subjectName, options) => {
-	const rule = Object.create(RuleProto);
-	rule._tag = kind;
-	rule.action = normalizeArray(action);
-	rule.subject = normalizeArray(subjectName);
-	if (options?.fields !== void 0) rule.fields = copyArray(wrapArray(options.fields));
-	if (options?.conditions !== void 0) rule.conditions = cloneSerializable(options.conditions);
-	if (options?.reason !== void 0) rule.reason = options.reason;
-	return Object.freeze(rule);
-};
-const builder = () => ({
-	allow: (action, subjectName, options) => makeRule("Allow", action, subjectName, options),
-	deny: (action, subjectName, options) => makeRule("Deny", action, subjectName, options)
-});
-/**
-* @internal
-*/
-const define = (() => (body, options) => {
-	const rules = [];
-	const iterator = body(builder());
-	let state = iterator.next();
-	while (!state.done) {
-		rules.push(state.value);
-		state = iterator.next(state.value);
-	}
-	return make(rules, options);
-});
-/**
-* @internal
-*/
-const subject = (subjectName, value) => {
-	const wrapped = Object.create(SubjectProto);
-	wrapped._tag = "Subject";
-	wrapped.subject = subjectName;
-	wrapped.value = value;
-	return Object.freeze(wrapped);
-};
-/**
-* @internal
-*/
-const isSubject = (value) => Predicate.hasProperty(value, SubjectTypeId);
-/**
-* @internal
-*/
-const isRule = (value) => Predicate.hasProperty(value, RuleTypeId);
-/**
-* @internal
-*/
-const isAbility = (value) => Predicate.hasProperty(value, TypeId);
-/**
-* @internal
-*/
-const unwrapSubject = (value) => isSubject(value) ? value.value : value;
-const detectFromConstructor = (value) => {
-	const constructor = value.constructor;
-	if (typeof constructor?.modelName === "string" && constructor.modelName.length > 0) return constructor.modelName;
-	if (typeof constructor?.name === "string" && constructor.name.length > 0) return constructor.name;
-};
-/**
-* @internal
-*/
-const detectSubjectType = Effect.fnUntraced(function* (self, value) {
-	if (isSubject(value)) return value.subject;
-	if (self.options.detectSubjectType !== void 0) return yield* Effect.try({
-		try: () => self.options.detectSubjectType?.(value),
-		catch: (cause) => new SubjectDetectionError({
-			reason: "Failed to detect subject type with the configured detector",
-			cause
-		})
-	});
-	const detected = detectFromConstructor(value);
-	if (detected !== void 0) return detected;
-	return yield* Effect.fail(new SubjectDetectionError({ reason: "Unable to detect subject type" }));
-});
-const hasOwnSubject = (request) => "subject" in request && typeof request.subject === "string";
-const hasOwnValue = (request) => "value" in request && typeof request.value === "object" && request.value !== null;
-const toRuntimeRequest = Effect.fnUntraced(function* (self, request) {
-	const runtime = {
-		action: request.action,
-		subject: ""
-	};
-	if (hasOwnSubject(request)) runtime.subject = request.subject;
-	else if (hasOwnValue(request)) runtime.subject = yield* detectSubjectType(self, request.value);
-	else return yield* Effect.fail(new SubjectDetectionError({ reason: "A check request must include either a subject or a value" }));
-	if (hasOwnValue(request)) runtime.value = unwrapSubject(request.value);
-	if (request.field !== void 0) runtime.field = request.field;
-	return runtime;
-});
-const toRuntimeSubjectRequest = Effect.fnUntraced(function* (self, request) {
-	const runtime = { subject: "" };
-	if (hasOwnSubject(request)) runtime.subject = request.subject;
-	else if (hasOwnValue(request)) runtime.subject = yield* detectSubjectType(self, request.value);
-	else return yield* Effect.fail(new SubjectDetectionError({ reason: "A subject query request must include either a subject or a value" }));
-	if (hasOwnValue(request)) runtime.value = unwrapSubject(request.value);
-	return runtime;
-});
-const matchesField = (candidate, request) => candidate.caslRule.matchesField(request.field);
-const isEmptyCondition = (conditions) => Object.keys(conditions).length === 0;
-const makeConditionError = (request, cause) => {
-	const error = {
-		action: request.action,
-		subject: request.subject,
-		cause
-	};
-	if (request.field !== void 0) error.field = request.field;
-	return new ConditionError(error);
-};
-const matchesConditions = Effect.fnUntraced(function* (candidate, request) {
-	const { rule } = candidate;
-	if (rule.conditions === void 0) return true;
-	if (request.value === void 0) return rule._tag === "Allow" || isEmptyCondition(rule.conditions);
-	return yield* Effect.try({
-		try: () => candidate.caslRule.matchesConditions(request.value),
-		catch: (cause) => makeConditionError(request, cause)
-	});
-});
-const matchesCandidateRule = Effect.fnUntraced(function* (candidate, request) {
-	if (!matchesField(candidate, request)) return false;
-	return yield* matchesConditions(candidate, request);
-});
-const getRuntimeRule = (state, caslRule) => {
-	const rule = state.rulesByRawRule.get(caslRule.origin);
-	if (rule === void 0) throw new Error("CASL rule is not owned by this Ability");
-	return rule;
-};
-const collectRuleCandidates = (self, request, order) => {
-	const state = getCaslState(self);
-	const candidates = state.ability.possibleRulesFor(request.action, request.subject).map((caslRule) => ({
-		rule: getRuntimeRule(state, caslRule),
-		caslRule
-	}));
-	const sorted = order === "descending" ? candidates : candidates.slice().sort((a, b) => (state.indexByRule.get(a.rule) ?? 0) - (state.indexByRule.get(b.rule) ?? 0));
-	return Object.freeze(sorted);
-};
-const possibleRulesForRequest = (self, request) => Object.freeze(collectRuleCandidates(self, request, "descending").map((candidate) => candidate.rule));
-const possibleRuleCandidatesForDefinitionOrder = (self, request) => collectRuleCandidates(self, request, "ascending");
-const relevantRuleForEffect = Effect.fnUntraced(function* (self, request) {
-	const candidates = collectRuleCandidates(self, request, "descending");
-	let index = 0;
-	while (index < candidates.length) {
-		const candidate = candidates[index];
-		if (candidate !== void 0) {
-			if (yield* matchesCandidateRule(candidate, request)) return candidate.rule;
-		}
-		index = index + 1;
-	}
-});
-const makeAuthorizationError = (request, rule) => {
-	const error = {
-		action: request.action,
-		subject: request.subject
-	};
-	if (request.field !== void 0) error.field = request.field;
-	if (rule?.reason !== void 0) error.reason = rule.reason;
-	return new AuthorizationError(error);
-};
-/**
-* @internal
-*/
-const check = dual(2, Effect.fnUntraced(function* (self, request) {
-	const runtimeRequest = yield* toRuntimeRequest(self, request);
-	const rule = yield* relevantRuleForEffect(self, runtimeRequest);
-	if (rule?._tag === "Allow") return;
-	return yield* Effect.fail(makeAuthorizationError(runtimeRequest, rule));
-}));
-/**
-* @internal
-*/
-const possibleRulesFor = dual(2, Effect.fnUntraced(function* (self, request) {
-	return possibleRulesForRequest(self, yield* toRuntimeRequest(self, request));
-}));
-/**
-* @internal
-*/
-const rulesFor = dual(2, Effect.fnUntraced(function* (self, request) {
-	const runtimeRequest = yield* toRuntimeRequest(self, request);
-	return Object.freeze(collectRuleCandidates(self, runtimeRequest, "descending").filter((candidate) => matchesField(candidate, runtimeRequest)).map((candidate) => candidate.rule));
-}));
-/**
-* @internal
-*/
-const relevantRuleFor = dual(2, Effect.fnUntraced(function* (self, request) {
-	return yield* relevantRuleForEffect(self, yield* toRuntimeRequest(self, request));
-}));
-/**
-* @internal
-*/
-const actionsFor = dual(2, Effect.fnUntraced(function* (self, request) {
-	const runtimeRequest = yield* toRuntimeSubjectRequest(self, request);
-	return unique(getCaslState(self).ability.actionsFor(runtimeRequest.subject));
-}));
-const rawRuleError = (reason, ruleIndex, cause) => {
-	const error = {
-		reason,
-		ruleIndex
-	};
-	if (cause !== void 0) error.cause = cause;
-	return new RawRuleError(error);
-};
-const validateArrayValue = (value, name, index) => {
-	if (Array.isArray(value) && value.length === 0) return Effect.fail(rawRuleError(`rawRule.${name} cannot be an empty array`, index));
-	return Effect.void;
-};
-const validateRawConditions = (conditions, index) => {
-	if (conditions === void 0) return Effect.void;
-	return Effect.asVoid(Effect.try({
-		try: () => mongoQueryMatcher(conditions),
-		catch: (cause) => rawRuleError("rawRule.conditions cannot be compiled", index, cause)
-	}));
-};
-/**
-* @internal
-*/
-const fromRawRules = Effect.fnUntraced(function* (rules, options) {
-	const built = [];
-	let index = 0;
-	for (const rawRule of rules) {
-		yield* validateArrayValue(rawRule.action, "action", index);
-		yield* validateArrayValue(rawRule.subject, "subject", index);
-		if (rawRule.fields !== void 0) yield* validateArrayValue(rawRule.fields, "fields", index);
-		yield* validateRawConditions(rawRule.conditions, index);
-		const ruleOptions = {};
-		if (rawRule.fields !== void 0) ruleOptions.fields = rawRule.fields;
-		if (rawRule.conditions !== void 0) ruleOptions.conditions = rawRule.conditions;
-		if (rawRule.reason !== void 0) ruleOptions.reason = rawRule.reason;
-		built.push(makeRule(rawRule.inverted === true ? "Deny" : "Allow", rawRule.action, rawRule.subject, ruleOptions));
-		index = index + 1;
-	}
-	return yield* Effect.try({
-		try: () => make(built, options),
-		catch: (cause) => cause instanceof AliasError ? cause : rawRuleError("Unable to construct Ability from raw rules", index, cause)
-	});
-});
-const updateEffect = (self, rules) => fromRawRules(rules, self.options);
-/**
-* @internal
-*/
-const update = dual(2, updateEffect);
-const ruleToRaw = (rule) => {
-	const raw = {
-		action: cloneSerializable(rule.action),
-		subject: cloneSerializable(rule.subject)
-	};
-	if (rule.fields !== void 0) raw.fields = cloneSerializable(rule.fields);
-	if (rule.conditions !== void 0) raw.conditions = cloneSerializable(rule.conditions);
-	if (rule._tag === "Deny") raw.inverted = true;
-	if (rule.reason !== void 0) raw.reason = rule.reason;
-	return Object.freeze(raw);
-};
-/**
-* @internal
-*/
-const toRawRules = Effect.fnUntraced(function* (self) {
-	const rawRules = [];
-	for (const rule of self.rules) rawRules.push(ruleToRaw(rule));
-	return Object.freeze(rawRules);
-});
-const fieldsForRule = (rule, options) => rule.fields ?? options.fieldsFrom(rule);
-/**
-* @internal
-*/
-const permittedFields = dual(3, Effect.fnUntraced(function* (self, request, options) {
-	const runtimeRequest = yield* toRuntimeRequest(self, request);
-	const candidates = possibleRuleCandidatesForDefinitionOrder(self, runtimeRequest);
-	const fields = /* @__PURE__ */ new Set();
-	let index = 0;
-	while (index < candidates.length) {
-		const candidate = candidates[index];
-		if (candidate !== void 0) {
-			if (yield* matchesConditions(candidate, runtimeRequest)) {
-				const ruleFields = fieldsForRule(candidate.rule, options);
-				for (const field of ruleFields) if (candidate.rule._tag === "Allow") fields.add(field);
-				else fields.delete(field);
-			}
-		}
-		index = index + 1;
-	}
-	return Object.freeze(Array.from(fields));
-}));
-//#endregion
-export { AliasError, AuthorizationError, ConditionError, QueryGenerationError, RawRuleError, RuleTypeId, SubjectDetectionError, SubjectTypeId, TypeId, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject, update };

package/dist/internal/serializable.js

@@ -1,22 +0,0 @@
-//#region src/internal/serializable.ts
-/**
-* @since 0.1.0
-*/
-/**
-* @internal
-*/
-const isPlainObject = (value) => value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
-/**
-* @internal
-*/
-const cloneSerializable = (value) => {
-	if (Array.isArray(value)) return Object.freeze(value.map(cloneSerializable));
-	if (isPlainObject(value)) {
-		const output = {};
-		for (const key of Object.keys(value)) output[key] = cloneSerializable(value[key]);
-		return Object.freeze(output);
-	}
-	return value;
-};
-//#endregion
-export { cloneSerializable, isPlainObject };