@nmnmcc/ability 0.1.0

package/dist/internal/ability.js

@@ -0,0 +1,624 @@
+import { cloneSerializable } from "./serializable.js";
+import { guard } from "@ucast/mongo2js";
+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 RuleIndexTypeId = Symbol.for("@nmnmcc/ability/Ability/ruleIndex");
+/**
+* @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 PredicateEvaluationError = class extends Data.TaggedError("PredicateEvaluationError") {};
+/**
+* @since 0.1.0
+* @category Errors
+*/
+var SerializationError = class extends Data.TaggedError("SerializationError") {};
+/**
+* @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,
+	when: rule.when,
+	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.when !== void 0) copy.when = rule.when;
+	if (rule.reason !== void 0) copy.reason = rule.reason;
+	return Object.freeze(copy);
+};
+const addIndexedRule = (index, subjectName, action, indexedRule) => {
+	let subjectIndex = index.get(subjectName);
+	if (subjectIndex === void 0) {
+		subjectIndex = /* @__PURE__ */ new Map();
+		index.set(subjectName, subjectIndex);
+	}
+	let rules = subjectIndex.get(action);
+	if (rules === void 0) {
+		rules = [];
+		subjectIndex.set(action, rules);
+	}
+	rules.push(indexedRule);
+};
+const freezeRuleIndex = (index) => {
+	const subjects = /* @__PURE__ */ new Map();
+	for (const [subjectName, actions] of index) {
+		const actionIndex = /* @__PURE__ */ new Map();
+		for (const [action, rules] of actions) actionIndex.set(action, Object.freeze(rules.slice().sort((a, b) => b.index - a.index)));
+		subjects.set(subjectName, actionIndex);
+	}
+	return Object.freeze({ rulesBySubject: subjects });
+};
+const buildRuleIndex = (rules, aliases) => {
+	const resolver = createAliasResolver(aliases ?? {});
+	const index = /* @__PURE__ */ new Map();
+	let ruleIndex = 0;
+	for (const rule of rules) {
+		const indexedRule = {
+			rule,
+			index: ruleIndex
+		};
+		const actions = resolver(rule.action);
+		const subjects = wrapArray(rule.subject);
+		for (const subjectName of subjects) for (const action of actions) addIndexedRule(index, subjectName, action, indexedRule);
+		ruleIndex = ruleIndex + 1;
+	}
+	return freezeRuleIndex(index);
+};
+const getRuleIndex = (self) => self[RuleIndexTypeId];
+/**
+* @internal
+*/
+const make = (rules, options) => {
+	const self = Object.create(AbilityProto);
+	self.rules = Object.freeze(Array.from(rules, freezeRule));
+	self.options = freezeOptions(options);
+	self[RuleIndexTypeId] = buildRuleIndex(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?.when !== void 0) rule.when = options.when;
+	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 regexpSpecialChars = /[-/\\^$+?.()|[\]{}]/g;
+const regexpAny = /\.?\*+\.?/g;
+const regexpStars = /\*+/;
+const regexpDot = /\./g;
+const detectRegexpPattern = (match, index, source) => {
+	const quantifier = source[0] === "*" || match[0] === "." && match[match.length - 1] === "." ? "+" : "*";
+	const matcher = match.includes("**") ? "." : "[^.]";
+	const pattern = match.replace(regexpDot, "\\$&").replace(regexpStars, matcher + quantifier);
+	return index + match.length === source.length ? `(?:${pattern})?` : pattern;
+};
+const escapeRegexp = (match, index, source) => {
+	if (match === "." && (source[index - 1] === "*" || source[index + 1] === "*")) return match;
+	return `\\${match}`;
+};
+const createFieldPattern = (fields) => {
+	const patterns = fields.map((field) => field.replace(regexpSpecialChars, escapeRegexp).replace(regexpAny, detectRegexpPattern));
+	const pattern = patterns.length > 1 ? `(?:${patterns.join("|")})` : patterns[0] ?? "";
+	return new RegExp(`^${pattern}$`);
+};
+const createFieldMatcher = (fields) => {
+	const pattern = fields.some((field) => field.includes("*")) ? createFieldPattern(fields) : void 0;
+	return pattern === void 0 ? (field) => fields.includes(field) : (field) => pattern.test(field);
+};
+const matchesField = (rule, request) => {
+	if (rule.fields === void 0) return true;
+	if (request.field === void 0) return rule._tag === "Allow";
+	return createFieldMatcher(rule.fields)(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 makePredicateEvaluationError = (request, cause) => {
+	const error = {
+		action: request.action,
+		subject: request.subject,
+		cause
+	};
+	if (request.field !== void 0) error.field = request.field;
+	return new PredicateEvaluationError(error);
+};
+const matchesConditions = Effect.fnUntraced(function* (rule, request) {
+	if (rule.conditions === void 0) return true;
+	if (request.value === void 0) return rule._tag === "Allow" || isEmptyCondition(rule.conditions);
+	return yield* Effect.try({
+		try: () => guard(rule.conditions)(request.value),
+		catch: (cause) => makeConditionError(request, cause)
+	});
+});
+const matchesPredicate = Effect.fnUntraced(function* (rule, request) {
+	if (rule.when === void 0) return true;
+	if (request.value === void 0) return false;
+	const result = yield* Effect.try({
+		try: () => rule.when?.(request.value) ?? true,
+		catch: (cause) => makePredicateEvaluationError(request, cause)
+	});
+	return Effect.isEffect(result) ? yield* result : result;
+});
+const matchesCandidateRule = Effect.fnUntraced(function* (rule, request) {
+	if (!matchesField(rule, request)) return false;
+	if (!(yield* matchesConditions(rule, request))) return false;
+	return yield* matchesPredicate(rule, request);
+});
+const collectIndexedRules = (self, request, order) => {
+	const collected = /* @__PURE__ */ new Map();
+	const pairs = [[request.subject, request.action]];
+	if (request.action !== anyAction) pairs.push([request.subject, anyAction]);
+	if (request.subject !== anySubject) pairs.push([anySubject, request.action]);
+	if (request.subject !== anySubject && request.action !== anyAction) pairs.push([anySubject, anyAction]);
+	for (const [subjectName, action] of pairs) {
+		const rules = getRuleIndex(self).rulesBySubject.get(subjectName)?.get(action);
+		if (rules !== void 0) for (const indexedRule of rules) collected.set(indexedRule.rule, indexedRule);
+	}
+	const sorted = Array.from(collected.values()).sort((a, b) => order === "descending" ? b.index - a.index : a.index - b.index);
+	return Object.freeze(sorted.map((indexedRule) => indexedRule.rule));
+};
+const possibleRulesForRequest = (self, request) => collectIndexedRules(self, request, "descending");
+const possibleRulesForDefinitionOrder = (self, request) => collectIndexedRules(self, request, "ascending");
+const relevantRuleForEffect = Effect.fnUntraced(function* (self, request) {
+	const rules = possibleRulesForRequest(self, request);
+	let index = 0;
+	while (index < rules.length) {
+		const rule = rules[index];
+		if (rule !== void 0) {
+			if (yield* matchesCandidateRule(rule, request)) return 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(possibleRulesForRequest(self, runtimeRequest).filter((rule) => matchesField(rule, runtimeRequest)));
+}));
+/**
+* @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);
+	const actions = /* @__PURE__ */ new Set();
+	const collect = (subjectName) => {
+		const subjectIndex = getRuleIndex(self).rulesBySubject.get(subjectName);
+		if (subjectIndex !== void 0) for (const action of subjectIndex.keys()) actions.add(action);
+	};
+	collect(runtimeRequest.subject);
+	if (runtimeRequest.subject !== anySubject) collect(anySubject);
+	return unique(actions);
+}));
+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: () => guard(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 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, options) {
+	const strict = options?.strict !== false;
+	const rawRules = [];
+	let index = 0;
+	for (const rule of self.rules) {
+		if (strict && rule.when !== void 0) return yield* Effect.fail(new SerializationError({
+			reason: "Cannot serialize rules with function predicates in strict mode",
+			ruleIndex: index
+		}));
+		rawRules.push(ruleToRaw(rule));
+		index = index + 1;
+	}
+	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 rules = possibleRulesForDefinitionOrder(self, runtimeRequest);
+	const fields = /* @__PURE__ */ new Set();
+	let index = 0;
+	while (index < rules.length) {
+		const rule = rules[index];
+		if (rule !== void 0) {
+			if (yield* matchesConditions(rule, runtimeRequest)) {
+				if (yield* matchesPredicate(rule, runtimeRequest)) {
+					const ruleFields = fieldsForRule(rule, options);
+					for (const field of ruleFields) if (rule._tag === "Allow") fields.add(field);
+					else fields.delete(field);
+				}
+			}
+		}
+		index = index + 1;
+	}
+	return Object.freeze(Array.from(fields));
+}));
+//#endregion
+export { AliasError, AuthorizationError, ConditionError, PredicateEvaluationError, QueryGenerationError, RawRuleError, RuleTypeId, SerializationError, SubjectDetectionError, SubjectTypeId, TypeId, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject };

package/dist/internal/serializable.js

@@ -0,0 +1,22 @@
+//#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 };