@eleven-am/golem-core 0.1.0

package/dist/operations.js

@@ -0,0 +1,484 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GolemEngine = void 0;
+const authorization_1 = require("./authorization");
+const errors_1 = require("./errors");
+const concurrency_1 = require("./concurrency");
+const event_buffer_1 = require("./event-buffer");
+const naming_1 = require("./naming");
+const model_meta_1 = require("./model-meta");
+const nested_writes_1 = require("./nested-writes");
+const readtree_1 = require("./readtree");
+const verify_1 = require("./verify");
+const PRISMA_CODE_PATTERN = /^P\d+$/;
+function translateError(error, model) {
+    if (error instanceof Error) {
+        if (error.name === 'PrismaClientValidationError') {
+            throw new errors_1.GolemValidationError(error.message);
+        }
+        const code = error.code;
+        if (typeof code === 'string' && PRISMA_CODE_PATTERN.test(code)) {
+            if (code === 'P2025') {
+                throw new errors_1.GolemNotFoundError(`${model} not found`);
+            }
+            if (code === 'P2002') {
+                throw new errors_1.GolemConflictError(`Unique constraint violation on ${model}`);
+            }
+            if (code === 'P2003' || code === 'P2014') {
+                throw new errors_1.GolemValidationError(`The requested change violates a relation constraint on ${model}`);
+            }
+        }
+    }
+    throw error;
+}
+class GolemEngine {
+    client;
+    modelsByName;
+    metadata;
+    hooks;
+    takeLimits;
+    authorization;
+    maxDepth;
+    checkWriteResults;
+    checkReadFields;
+    authorizationSessions = new WeakMap();
+    constructor(client, models, options = {}) {
+        this.client = client;
+        this.modelsByName = new Map(models.map((m) => [m.name, m]));
+        this.metadata = (0, model_meta_1.buildModelMetadata)(models);
+        this.hooks = options.hooks;
+        this.takeLimits = options.takeLimits ?? new Map();
+        this.authorization = options.authorization;
+        this.maxDepth = options.maxDepth ?? 5;
+        this.checkWriteResults = options.checkWriteResults ?? false;
+        this.checkReadFields = options.checkReadFields ?? false;
+        if (this.checkReadFields && this.authorization) {
+            const missing = [
+                !this.authorization.classifyFields ? 'classifyFields' : null,
+                !this.authorization.checkField ? 'checkField' : null,
+            ].filter(Boolean);
+            if (missing.length > 0) {
+                throw new Error(`checkReadFields is enabled but the authorization provider does not implement ${missing.join(' and ')}`);
+            }
+        }
+        if (this.checkWriteResults && this.authorization) {
+            const missing = [
+                !this.authorization.check ? 'check' : null,
+                !this.authorization.checkField ? 'checkField' : null,
+            ].filter(Boolean);
+            if (missing.length > 0) {
+                throw new Error(`checkWriteResults is enabled but the authorization provider does not implement ${missing.join(' and ')}`);
+            }
+        }
+    }
+    verifyContext(context) {
+        return {
+            modelsByName: this.modelsByName,
+            metadata: this.metadata,
+            provider: this.enforced(context),
+            context,
+        };
+    }
+    pkOf(model) {
+        const pk = this.metadata.get(model)?.primaryKey;
+        if (!pk) {
+            throw new errors_1.GolemValidationError(`Model ${model} has no primary key field`);
+        }
+        return pk;
+    }
+    async prepareRead(request) {
+        return (0, readtree_1.prepareReadTree)({
+            model: this.modelsByName.get(request.model),
+            modelsByName: this.modelsByName,
+            select: request.select,
+            include: request.include,
+            provider: this.enforced(request.context),
+            context: request.context,
+            maxDepth: this.maxDepth,
+            readFieldChecks: this.checkReadFields,
+            metadata: this.metadata,
+        });
+    }
+    async finishRead(result, prepared, context) {
+        if (!result) {
+            return result;
+        }
+        if (prepared.toOneChecks.length > 0) {
+            await (0, readtree_1.applyToOneChecks)(result, prepared.toOneChecks, this.authorization, context);
+        }
+        if (prepared.maskChecks.length > 0) {
+            await (0, readtree_1.applyFieldMasks)(result, prepared.maskChecks, this.authorization, context);
+        }
+        if (prepared.injected.length > 0) {
+            await (0, readtree_1.stripInjectedFields)(result, prepared.injected);
+        }
+        return result;
+    }
+    enforced(context) {
+        if (!this.authorization || context === undefined) {
+            return undefined;
+        }
+        if (!context || typeof context !== 'object')
+            return this.authorization;
+        const cached = this.authorizationSessions.get(context);
+        if (cached)
+            return cached;
+        const source = this.authorization;
+        const values = new Map();
+        const memo = (key, load) => {
+            const existing = values.get(key);
+            if (existing)
+                return existing;
+            const pending = load();
+            values.set(key, pending);
+            return pending;
+        };
+        const session = {
+            authorize: (action, model, ctx) => memo(`authorize:${action}:${model}`, () => source.authorize(action, model, ctx)),
+            constrain: (action, model, ctx) => memo(`constrain:${action}:${model}`, () => source.constrain(action, model, ctx)),
+            check: source.check?.bind(source),
+            checkField: source.checkField?.bind(source),
+            classifyFields: source.classifyFields
+                ? (action, model, fields, ctx) => memo(`classify:${action}:${model}:${[...fields].sort().join('\u0000')}`, () => source.classifyFields(action, model, fields, ctx))
+                : undefined,
+            freshContext: source.freshContext?.bind(source),
+        };
+        this.authorizationSessions.set(context, session);
+        return session;
+    }
+    async constraintFor(action, model, context) {
+        const provider = this.enforced(context);
+        if (!provider) {
+            return undefined;
+        }
+        return provider.constrain(action, model, context);
+    }
+    async authorizeNestedWrites(model, data, context) {
+        const provider = this.enforced(context);
+        if (!provider) {
+            return;
+        }
+        await this.walkNestedWrites(provider, model, data, context);
+    }
+    async walkNestedWrites(provider, model, data, context) {
+        if (!data || typeof data !== 'object') {
+            return;
+        }
+        const definition = this.modelsByName.get(model);
+        if (!definition) {
+            return;
+        }
+        for (const relation of (0, nested_writes_1.planNestedWrites)(this.metadata, definition, data)) {
+            for (const action of relation.modelActions) {
+                await provider.authorize(action, relation.target.name, context);
+            }
+            for (const nested of [...relation.createPayloads, ...relation.updatePayloads]) {
+                await this.walkNestedWrites(provider, relation.target.name, nested, context);
+            }
+        }
+    }
+    async resolveConstrainedTarget(action, request) {
+        const constraint = await this.constraintFor(action, request.model, request.context);
+        if (constraint === undefined) {
+            return { where: request.where };
+        }
+        const pkField = this.metadata.get(request.model)?.primaryKey;
+        if (!pkField) {
+            throw new errors_1.GolemValidationError(`Model ${request.model} has no primary key field`);
+        }
+        const delegate = this.delegate(request.model);
+        const found = (await this.run(request.model, () => delegate.findFirst({
+            where: (0, authorization_1.mergeConstraint)(request.where, constraint),
+            select: { [pkField.name]: true },
+        })));
+        if (!found) {
+            throw new errors_1.GolemNotFoundError(`${request.model} not found`);
+        }
+        return { where: { [pkField.name]: found[pkField.name] }, row: found };
+    }
+    async runBefore(operation, request) {
+        if (!this.hooks) {
+            return request;
+        }
+        let current = request;
+        for (const hook of this.hooks.beforeFor(request.model, operation)) {
+            const result = await hook(current, {
+                model: request.model,
+                operation,
+                context: request.context,
+            });
+            if (result !== undefined) {
+                current = result;
+            }
+        }
+        return current;
+    }
+    async runAfter(operation, model, result, context) {
+        if (!this.hooks) {
+            return;
+        }
+        for (const hook of this.hooks.afterFor(model, operation)) {
+            await hook(result, { model, operation, context });
+        }
+    }
+    enforceTakeLimit(request) {
+        const limit = this.takeLimits.get(request.model);
+        if (limit !== undefined && request.take !== undefined && Math.abs(request.take) > limit) {
+            throw new errors_1.GolemValidationError(`take ${request.take} exceeds the maximum of ${limit} for ${request.model}`);
+        }
+    }
+    delegate(model) {
+        if (!this.modelsByName.has(model)) {
+            throw new errors_1.GolemValidationError(`Unknown model ${model}`);
+        }
+        const delegate = this.client[(0, naming_1.lcFirst)(model)];
+        if (!delegate) {
+            throw new errors_1.GolemValidationError(`Prisma client has no delegate for model ${model}`);
+        }
+        return delegate;
+    }
+    async run(model, action) {
+        try {
+            return await action();
+        }
+        catch (error) {
+            translateError(error, model);
+        }
+    }
+    async findOne(request) {
+        const delegate = this.delegate(request.model);
+        const req = await this.runBefore('findOne', request);
+        const prepared = await this.prepareRead(req);
+        const constraint = await this.constraintFor('read', req.model, req.context);
+        const found = await this.run(req.model, () => constraint === undefined
+            ? delegate.findUnique({ where: req.where, select: prepared.select, include: prepared.include })
+            : delegate.findFirst({
+                where: (0, authorization_1.mergeConstraint)(req.where, constraint),
+                select: prepared.select,
+                include: prepared.include,
+            }));
+        await this.finishRead(found, prepared, req.context);
+        await this.runAfter('findOne', req.model, found, req.context);
+        return found;
+    }
+    async findMany(request) {
+        const delegate = this.delegate(request.model);
+        const req = await this.runBefore('findMany', request);
+        this.enforceTakeLimit(req);
+        const prepared = await this.prepareRead(req);
+        const constraint = await this.constraintFor('read', req.model, req.context);
+        const found = (await this.run(req.model, () => delegate.findMany({
+            where: (0, authorization_1.mergeConstraint)(req.where, constraint),
+            orderBy: req.orderBy,
+            take: req.take,
+            skip: req.skip,
+            cursor: req.cursor,
+            distinct: req.distinct,
+            select: prepared.select,
+            include: prepared.include,
+        })));
+        await this.finishRead(found, prepared, req.context);
+        await this.runAfter('findMany', req.model, found, req.context);
+        return found;
+    }
+    async findFirst(request) {
+        const delegate = this.delegate(request.model);
+        const prepared = await this.prepareRead(request);
+        const constraint = await this.constraintFor('read', request.model, request.context);
+        const found = await this.run(request.model, () => delegate.findFirst({
+            where: (0, authorization_1.mergeConstraint)(request.where, constraint),
+            select: prepared.select,
+            include: prepared.include,
+        }));
+        return this.finishRead(found, prepared, request.context);
+    }
+    async create(request) {
+        const delegate = this.delegate(request.model);
+        const req = await this.runBefore('create', request);
+        const provider = this.enforced(req.context);
+        if (provider) {
+            await provider.authorize('create', req.model, req.context);
+            await this.authorizeNestedWrites(req.model, req.data, req.context);
+        }
+        const prepared = await this.prepareRead(req);
+        let created;
+        let createPlanFast = false;
+        let createPlan;
+        if (provider && this.checkWriteResults) {
+            const model = this.modelsByName.get(req.model);
+            const vctx = this.verifyContext(req.context);
+            const constraint = await this.constraintFor('create', req.model, req.context);
+            createPlan = await (0, verify_1.planVerification)(vctx, model, req.data, constraint, 'create');
+            createPlanFast = createPlan.fastPath;
+        }
+        if (provider && this.checkWriteResults && !createPlanFast) {
+            const model = this.modelsByName.get(req.model);
+            const pk = this.pkOf(req.model);
+            const vctx = this.verifyContext(req.context);
+            created = await (0, event_buffer_1.withBufferedEvents)(() => this.run(req.model, () => this.client.$transaction(async (tx) => {
+                const txDelegate = tx[(0, naming_1.lcFirst)(req.model)];
+                const wide = await txDelegate.create({
+                    data: req.data,
+                    select: { ...createPlan.select, [pk.name]: true },
+                });
+                await (0, verify_1.verifyCreatedTree)(vctx, model, wide, req.data);
+                return txDelegate.findUnique({
+                    where: { [pk.name]: wide[pk.name] },
+                    select: prepared.select,
+                    include: prepared.include,
+                });
+            })));
+        }
+        else {
+            created = await this.run(req.model, () => delegate.create({ data: req.data, select: prepared.select, include: prepared.include }));
+        }
+        await this.finishRead(created, prepared, req.context);
+        await this.runAfter('create', req.model, created, req.context);
+        return created;
+    }
+    async update(request) {
+        const delegate = this.delegate(request.model);
+        const req = await this.runBefore('update', request);
+        await this.authorizeNestedWrites(req.model, req.data, req.context);
+        const provider = this.enforced(req.context);
+        const prepared = await this.prepareRead(req);
+        let updated;
+        let updatePlan;
+        let updateConstraint;
+        if (provider && this.checkWriteResults) {
+            const model = this.modelsByName.get(req.model);
+            const vctx = this.verifyContext(req.context);
+            updateConstraint = await this.constraintFor('update', req.model, req.context);
+            updatePlan = await (0, verify_1.planVerification)(vctx, model, req.data, updateConstraint, 'update');
+        }
+        if (provider && this.checkWriteResults && updatePlan && !updatePlan.fastPath) {
+            const model = this.modelsByName.get(req.model);
+            const pk = this.pkOf(req.model);
+            const vctx = this.verifyContext(req.context);
+            const constraint = updateConstraint;
+            const wide = { ...updatePlan.select, [pk.name]: true };
+            updated = await (0, event_buffer_1.withBufferedEvents)(() => this.run(req.model, () => this.client.$transaction(async (tx) => {
+                const txDelegate = tx[(0, naming_1.lcFirst)(req.model)];
+                const before = await txDelegate.findFirst({
+                    where: (0, authorization_1.mergeConstraint)(req.where, constraint),
+                    select: wide,
+                });
+                if (!before) {
+                    throw new errors_1.GolemNotFoundError(`${req.model} not found`);
+                }
+                const after = await txDelegate.update({
+                    where: { [pk.name]: before[pk.name] },
+                    data: req.data,
+                    select: wide,
+                });
+                await (0, verify_1.verifyUpdatedRow)(vctx, model, before, after, req.data);
+                return txDelegate.findUnique({
+                    where: { [pk.name]: before[pk.name] },
+                    select: prepared.select,
+                    include: prepared.include,
+                });
+            })));
+        }
+        else {
+            const target = await this.resolveConstrainedTarget('update', req);
+            updated = await this.run(req.model, () => delegate.update({
+                where: target.where,
+                data: req.data,
+                select: prepared.select,
+                include: prepared.include,
+            }));
+        }
+        await this.finishRead(updated, prepared, req.context);
+        await this.runAfter('update', req.model, updated, req.context);
+        return updated;
+    }
+    async updateMany(request) {
+        const delegate = this.delegate(request.model);
+        const req = await this.runBefore('updateMany', request);
+        await this.authorizeNestedWrites(req.model, req.data, req.context);
+        const constraint = await this.constraintFor('update', req.model, req.context);
+        const provider = this.enforced(req.context);
+        let result;
+        let manyPlan;
+        if (provider && this.checkWriteResults) {
+            const vctx = this.verifyContext(req.context);
+            manyPlan = await (0, verify_1.planVerification)(vctx, this.modelsByName.get(req.model), req.data, constraint, 'update');
+        }
+        if (provider && this.checkWriteResults && manyPlan && !manyPlan.fastPath) {
+            const model = this.modelsByName.get(req.model);
+            const pk = this.pkOf(req.model);
+            const vctx = this.verifyContext(req.context);
+            const scalars = { ...manyPlan.select, [pk.name]: true };
+            result = (await (0, event_buffer_1.withBufferedEvents)(() => this.run(req.model, () => this.client.$transaction(async (tx) => {
+                const txDelegate = tx[(0, naming_1.lcFirst)(req.model)];
+                const beforeRows = (await txDelegate.findMany({
+                    where: (0, authorization_1.mergeConstraint)(req.where, constraint),
+                    select: scalars,
+                }));
+                const ids = beforeRows.map((row) => row[pk.name]);
+                await txDelegate.updateMany({ where: { [pk.name]: { in: ids } }, data: req.data });
+                const afterRows = (await txDelegate.findMany({
+                    where: { [pk.name]: { in: ids } },
+                    select: scalars,
+                }));
+                const afterById = new Map(afterRows.map((row) => [row[pk.name], row]));
+                await (0, concurrency_1.runPolicyChecks)(beforeRows.map((before) => async () => {
+                    const after = afterById.get(before[pk.name]);
+                    if (after) {
+                        await (0, verify_1.verifyUpdatedRow)(vctx, model, before, after, req.data);
+                    }
+                }));
+                return { count: ids.length };
+            }))));
+        }
+        else {
+            result = (await this.run(req.model, () => delegate.updateMany({ where: (0, authorization_1.mergeConstraint)(req.where, constraint), data: req.data })));
+        }
+        await this.runAfter('updateMany', req.model, result, req.context);
+        return result;
+    }
+    async delete(request) {
+        const delegate = this.delegate(request.model);
+        const req = await this.runBefore('delete', request);
+        const { where } = await this.resolveConstrainedTarget('delete', req);
+        const prepared = await this.prepareRead(req);
+        const deleted = await this.run(req.model, () => delegate.delete({ where, select: prepared.select, include: prepared.include }));
+        await this.finishRead(deleted, prepared, req.context);
+        await this.runAfter('delete', req.model, deleted, req.context);
+        return deleted;
+    }
+    async upsert(request) {
+        const delegate = this.delegate(request.model);
+        const pkField = this.metadata.get(request.model)?.primaryKey;
+        if (!pkField) {
+            throw new errors_1.GolemValidationError(`Model ${request.model} has no primary key field`);
+        }
+        const existing = await this.run(request.model, () => delegate.findFirst({ where: request.where, select: { [pkField.name]: true } }));
+        if (existing) {
+            return this.update({
+                model: request.model,
+                where: request.where,
+                data: request.update,
+                select: request.select,
+                include: request.include,
+                context: request.context,
+            });
+        }
+        return this.create({
+            model: request.model,
+            data: request.create,
+            select: request.select,
+            include: request.include,
+            context: request.context,
+        });
+    }
+    async deleteMany(request) {
+        const delegate = this.delegate(request.model);
+        const req = await this.runBefore('deleteMany', request);
+        const constraint = await this.constraintFor('delete', req.model, req.context);
+        const result = (await this.run(req.model, () => delegate.deleteMany({ where: (0, authorization_1.mergeConstraint)(req.where, constraint) })));
+        await this.runAfter('deleteMany', req.model, result, req.context);
+        return result;
+    }
+}
+exports.GolemEngine = GolemEngine;

package/dist/publisher.d.ts

@@ -0,0 +1,16 @@
+import { DatamodelDocument } from './datamodel';
+import { GolemEventBus } from './events';
+export interface GolemQueryParams {
+    model?: string;
+    operation: string;
+    args: any;
+    query: (args: any) => Promise<any>;
+    findExisting?: (where: unknown, select: Record<string, true>) => Promise<unknown>;
+}
+export type GolemQueryInterceptor = (params: GolemQueryParams) => Promise<any>;
+export interface CreateEventPublisherOptions {
+    datamodel: DatamodelDocument<any>;
+    eventBus: GolemEventBus;
+    models: ReadonlySet<string>;
+}
+export declare function createEventPublisher(options: CreateEventPublisherOptions): GolemQueryInterceptor;

package/dist/publisher.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventPublisher = createEventPublisher;
+const event_buffer_1 = require("./event-buffer");
+const events_1 = require("./events");
+const OPERATION_EVENTS = {
+    create: 'CREATED',
+    update: 'UPDATED',
+    delete: 'DELETED',
+};
+function createEventPublisher(options) {
+    const pkByModel = new Map();
+    for (const model of options.datamodel.models) {
+        const pk = model.fields.find((f) => f.isId);
+        if (pk) {
+            pkByModel.set(model.name, pk.name);
+        }
+    }
+    return async ({ model, operation, args, query, findExisting }) => {
+        let type = OPERATION_EVENTS[operation];
+        if (operation === 'upsert') {
+            if (!model || !options.models.has(model))
+                return query(args);
+            const pk = pkByModel.get(model);
+            if (!pk || !findExisting)
+                return query(args);
+            const existing = await findExisting(args?.where, { [pk]: true });
+            type = existing ? 'UPDATED' : 'CREATED';
+        }
+        if (!type || !model || !options.models.has(model)) {
+            return query(args);
+        }
+        const pk = pkByModel.get(model);
+        if (!pk) {
+            return query(args);
+        }
+        const finalArgs = args?.select ? { ...args, select: { ...args.select, [pk]: true } } : args;
+        const result = await query(finalArgs);
+        const payload = {
+            type,
+            model,
+            id: result[pk],
+            ...(type === 'DELETED' && result && typeof result === 'object'
+                ? { entity: result }
+                : {}),
+        };
+        const deferred = (0, event_buffer_1.bufferEvent)({
+            publish: () => options.eventBus.publish((0, events_1.eventTopic)(model), payload),
+        });
+        if (!deferred) {
+            await options.eventBus.publish((0, events_1.eventTopic)(model), payload);
+        }
+        return result;
+    };
+}

package/dist/readtree.d.ts

@@ -0,0 +1,40 @@
+import { AuthorizationProvider } from './authorization';
+import { DatamodelModel } from './datamodel';
+import { ModelMetadataIndex } from './model-meta';
+export interface ToOneCheck {
+    path: readonly string[];
+    model: string;
+}
+export interface FieldMaskCheck {
+    path: readonly string[];
+    model: string;
+    field: string;
+}
+export interface InjectedField {
+    path: readonly string[];
+    field: string;
+}
+export interface PreparedReadTree {
+    select?: Record<string, unknown>;
+    include?: Record<string, unknown>;
+    toOneChecks: ToOneCheck[];
+    maskChecks: FieldMaskCheck[];
+    injected: InjectedField[];
+}
+interface PrepareOptions {
+    model: DatamodelModel;
+    modelsByName: Map<string, DatamodelModel>;
+    select?: Record<string, unknown>;
+    include?: Record<string, unknown>;
+    provider?: AuthorizationProvider;
+    context?: unknown;
+    maxDepth: number;
+    readFieldChecks?: boolean;
+    metadata?: ModelMetadataIndex;
+}
+export declare function constraintFieldNames(constraint: unknown, into?: Set<string>): Set<string>;
+export declare function prepareReadTree(options: PrepareOptions): Promise<PreparedReadTree>;
+export declare function applyToOneChecks(data: unknown, checks: readonly ToOneCheck[], provider: AuthorizationProvider, context: unknown): Promise<void>;
+export declare function applyFieldMasks(data: unknown, checks: readonly FieldMaskCheck[], provider: AuthorizationProvider, context: unknown): Promise<void>;
+export declare function stripInjectedFields(data: unknown, injected: readonly InjectedField[]): Promise<void>;
+export {};