@eleven-am/golem-core 0.1.0

package/dist/typemap.d.ts

@@ -0,0 +1,53 @@
+import { GolemOperation } from './hooks';
+import { BatchResult } from './operations';
+import { PrismaSelect } from './select';
+export interface GolemTypeShape {
+    entity: unknown;
+    create: unknown;
+    update: unknown;
+    updateMany: unknown;
+    where: unknown;
+    whereUnique: unknown;
+    orderBy: unknown;
+}
+export type GolemTypesMap = Record<string, GolemTypeShape>;
+export type HookRequestFor<TTypes extends GolemTypesMap, M extends keyof TTypes & string, O extends GolemOperation> = O extends 'create' ? {
+    model: M;
+    data: TTypes[M]['create'];
+    select?: PrismaSelect;
+    context?: unknown;
+} : O extends 'update' ? {
+    model: M;
+    where: TTypes[M]['whereUnique'];
+    data: TTypes[M]['update'];
+    select?: PrismaSelect;
+    context?: unknown;
+} : O extends 'updateMany' ? {
+    model: M;
+    where?: TTypes[M]['where'];
+    data: TTypes[M]['updateMany'];
+    context?: unknown;
+} : O extends 'delete' ? {
+    model: M;
+    where: TTypes[M]['whereUnique'];
+    select?: PrismaSelect;
+    context?: unknown;
+} : O extends 'deleteMany' ? {
+    model: M;
+    where?: TTypes[M]['where'];
+    context?: unknown;
+} : O extends 'findOne' ? {
+    model: M;
+    where: TTypes[M]['whereUnique'];
+    select?: PrismaSelect;
+    context?: unknown;
+} : O extends 'findMany' ? {
+    model: M;
+    where?: TTypes[M]['where'];
+    orderBy?: TTypes[M]['orderBy'] | TTypes[M]['orderBy'][];
+    take?: number;
+    skip?: number;
+    select?: PrismaSelect;
+    context?: unknown;
+} : never;
+export type HookResultFor<TTypes extends GolemTypesMap, M extends keyof TTypes & string, O extends GolemOperation> = O extends 'create' | 'update' | 'delete' ? Partial<TTypes[M]['entity']> : O extends 'findOne' ? Partial<TTypes[M]['entity']> | null : O extends 'findMany' ? Partial<TTypes[M]['entity']>[] : BatchResult;

package/dist/typemap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/verify.d.ts

@@ -0,0 +1,21 @@
+import { AuthorizationProvider } from './authorization';
+import { DatamodelModel } from './datamodel';
+import { ModelMetadataIndex } from './model-meta';
+import { NestedRelationWritePlan } from './nested-writes';
+import { PrismaSelect } from './select';
+export interface VerifyContext {
+    modelsByName: Map<string, DatamodelModel>;
+    metadata?: ModelMetadataIndex;
+    provider: AuthorizationProvider;
+    context: unknown;
+}
+export declare function modelScalarSelect(model: DatamodelModel): PrismaSelect;
+export declare function touchedRelations(modelsByName: Map<string, DatamodelModel>, model: DatamodelModel, data: Record<string, unknown>): readonly NestedRelationWritePlan[];
+export declare function wideSelect(modelsByName: Map<string, DatamodelModel>, model: DatamodelModel, data: Record<string, unknown>): PrismaSelect;
+export declare function verifyCreatedTree(ctx: VerifyContext, model: DatamodelModel, row: Record<string, unknown>, data: Record<string, unknown>): Promise<void>;
+export declare function verifyUpdatedRow(ctx: VerifyContext, model: DatamodelModel, before: Record<string, unknown>, after: Record<string, unknown>, data: Record<string, unknown>): Promise<void>;
+export interface VerificationPlan {
+    select: PrismaSelect;
+    fastPath: boolean;
+}
+export declare function planVerification(ctx: VerifyContext, model: DatamodelModel, data: Record<string, unknown>, constraint: unknown, action: 'create' | 'update'): Promise<VerificationPlan>;

package/dist/verify.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelScalarSelect = modelScalarSelect;
+exports.touchedRelations = touchedRelations;
+exports.wideSelect = wideSelect;
+exports.verifyCreatedTree = verifyCreatedTree;
+exports.verifyUpdatedRow = verifyUpdatedRow;
+exports.planVerification = planVerification;
+const authorization_1 = require("./authorization");
+const concurrency_1 = require("./concurrency");
+const errors_1 = require("./errors");
+const model_meta_1 = require("./model-meta");
+const nested_writes_1 = require("./nested-writes");
+const readtree_1 = require("./readtree");
+function metadataFor(ctx) {
+    return ctx.metadata ?? (0, model_meta_1.buildModelMetadata)([...ctx.modelsByName.values()]);
+}
+function modelScalarSelect(model) {
+    const select = {};
+    for (const field of model.fields) {
+        if (field.kind !== 'object') {
+            select[field.name] = true;
+        }
+    }
+    return select;
+}
+function touchedRelations(modelsByName, model, data) {
+    return (0, nested_writes_1.planNestedWrites)((0, model_meta_1.buildModelMetadata)([...modelsByName.values()]), model, data);
+}
+function mergeSelect(into, source) {
+    for (const [name, value] of Object.entries(source)) {
+        const current = into[name];
+        if (current && current !== true && value !== true &&
+            typeof current === 'object' && typeof value === 'object' &&
+            current.select && value.select) {
+            mergeSelect(current.select, value.select);
+        }
+        else {
+            into[name] = value;
+        }
+    }
+}
+function wideSelect(modelsByName, model, data) {
+    const metadata = (0, model_meta_1.buildModelMetadata)([...modelsByName.values()]);
+    return wideSelectWithMetadata(metadata, model, data);
+}
+function wideSelectWithMetadata(metadata, model, data) {
+    const select = modelScalarSelect(model);
+    for (const relation of (0, nested_writes_1.planNestedWrites)(metadata, model, data)) {
+        const nestedSelect = modelScalarSelect(relation.target);
+        for (const payload of [...relation.createPayloads, ...relation.updatePayloads]) {
+            mergeSelect(nestedSelect, wideSelectWithMetadata(metadata, relation.target, payload));
+        }
+        select[relation.field.name] = { select: nestedSelect };
+    }
+    return select;
+}
+function payloadFieldNames(model, data) {
+    const names = new Set();
+    for (const field of model.fields) {
+        if (data[field.name] === undefined) {
+            continue;
+        }
+        if (field.kind === 'object') {
+            if (field.relationFromFields?.length === 1) {
+                names.add(field.relationFromFields[0]);
+            }
+            continue;
+        }
+        names.add(field.name);
+    }
+    return [...names];
+}
+async function checkRow(ctx, action, model, row) {
+    const allowed = await ctx.provider.check(action, model, row, ctx.context);
+    if (!allowed) {
+        throw new errors_1.GolemForbiddenError(`Cannot ${action} ${model} with the provided values`);
+    }
+}
+async function checkFields(ctx, action, model, entity, fields) {
+    await (0, concurrency_1.runPolicyChecks)(fields.map((field) => async () => {
+        const allowed = await ctx.provider.checkField(action, model, entity, field, ctx.context);
+        if (!allowed)
+            throw new errors_1.GolemForbiddenError(`Cannot ${action} field "${field}" on ${model}`);
+    }));
+}
+async function verifyAppearedRow(ctx, relation, row) {
+    await (0, concurrency_1.runPolicyChecks)([...relation.addedActions].map((action) => () => checkRow(ctx, action, relation.target.name, row)));
+    if (relation.addedActions.has('create')) {
+        const fieldUnion = new Set();
+        for (const payload of relation.createPayloads) {
+            for (const name of payloadFieldNames(relation.target, payload)) {
+                fieldUnion.add(name);
+            }
+        }
+        await checkFields(ctx, 'create', relation.target.name, row, [...fieldUnion]);
+        for (const payload of relation.createPayloads) {
+            await verifyCreatedChildren(ctx, relation.target, row, payload);
+        }
+    }
+}
+async function verifyCreatedChildren(ctx, model, row, data) {
+    for (const relation of (0, nested_writes_1.planNestedWrites)(metadataFor(ctx), model, data)) {
+        const value = row[relation.field.name];
+        const children = Array.isArray(value) ? value : value ? [value] : [];
+        await (0, concurrency_1.runPolicyChecks)(children.map((child) => () => verifyAppearedRow(ctx, relation, child)));
+    }
+}
+async function verifyCreatedTree(ctx, model, row, data) {
+    await checkRow(ctx, 'create', model.name, row);
+    await checkFields(ctx, 'create', model.name, row, payloadFieldNames(model, data));
+    await verifyCreatedChildren(ctx, model, row, data);
+}
+function scalarChanged(before, after) {
+    if (before instanceof Date || after instanceof Date) {
+        const a = before instanceof Date ? before.getTime() : before;
+        const b = after instanceof Date ? after.getTime() : after;
+        return a !== b;
+    }
+    return before !== after;
+}
+async function verifyUpdatedRow(ctx, model, before, after, data) {
+    const metadata = metadataFor(ctx);
+    await checkRow(ctx, 'update', model.name, after);
+    const changed = [];
+    for (const field of metadata.get(model.name)?.scalarFields ?? []) {
+        if (scalarChanged(before[field.name], after[field.name])) {
+            changed.push(field.name);
+        }
+    }
+    await checkFields(ctx, 'update', model.name, before, changed);
+    for (const relation of (0, nested_writes_1.planNestedWrites)(metadata, model, data)) {
+        const pk = metadata.get(relation.target.name)?.primaryKey;
+        if (!pk) {
+            continue;
+        }
+        const beforeValue = before[relation.field.name];
+        const afterValue = after[relation.field.name];
+        const beforeRows = Array.isArray(beforeValue) ? beforeValue : beforeValue ? [beforeValue] : [];
+        const afterRows = Array.isArray(afterValue) ? afterValue : afterValue ? [afterValue] : [];
+        const beforeById = new Map(beforeRows.map((row) => {
+            const record = row;
+            return [record[pk.name], record];
+        }));
+        const afterById = new Map(afterRows.map((row) => {
+            const record = row;
+            return [record[pk.name], record];
+        }));
+        for (const child of afterRows) {
+            const childRow = child;
+            const beforeChild = beforeById.get(childRow[pk.name]);
+            if (!beforeChild) {
+                await verifyAppearedRow(ctx, relation, childRow);
+                continue;
+            }
+            const childChanged = metadata
+                .get(relation.target.name)
+                .scalarFields
+                .filter((field) => scalarChanged(beforeChild[field.name], childRow[field.name]))
+                .map((field) => field.name);
+            if (relation.retainedActions.has('update') &&
+                (childChanged.length > 0 || (0, nested_writes_1.nestedPlanTargetsRow)(relation, beforeChild))) {
+                await checkRow(ctx, 'update', relation.target.name, childRow);
+                await checkFields(ctx, 'update', relation.target.name, beforeChild, childChanged);
+                for (const payload of relation.updatePayloads) {
+                    await verifyUpdatedChildren(ctx, relation.target, beforeChild, childRow, payload);
+                }
+            }
+        }
+        for (const child of beforeRows) {
+            const childRow = child;
+            if (afterById.has(childRow[pk.name]))
+                continue;
+            await (0, concurrency_1.runPolicyChecks)([...relation.removedActions].map((action) => () => checkRow(ctx, action, relation.target.name, childRow)));
+        }
+    }
+}
+async function verifyUpdatedChildren(ctx, model, before, after, data) {
+    for (const relation of (0, nested_writes_1.planNestedWrites)(metadataFor(ctx), model, data)) {
+        const wrapperBefore = { ...before, [relation.field.name]: before[relation.field.name] };
+        const wrapperAfter = { ...after, [relation.field.name]: after[relation.field.name] };
+        await verifyRelationOnly(ctx, model, wrapperBefore, wrapperAfter, data, relation.field.name);
+    }
+}
+async function verifyRelationOnly(ctx, model, before, after, data, fieldName) {
+    const rootBefore = { ...before };
+    const rootAfter = { ...after };
+    for (const field of metadataFor(ctx).get(model.name)?.scalarFields ?? []) {
+        rootAfter[field.name] = rootBefore[field.name];
+    }
+    const narrowed = { [fieldName]: data[fieldName] };
+    // Reuse the same diff verifier while suppressing root scalar differences.
+    await verifyUpdatedRow(ctx, model, rootBefore, rootAfter, narrowed);
+}
+async function planVerification(ctx, model, data, constraint, action) {
+    const metadata = metadataFor(ctx);
+    const relations = (0, nested_writes_1.planNestedWrites)(metadata, model, data);
+    if (!ctx.provider.classifyFields) {
+        return { select: wideSelectWithMetadata(metadata, model, data), fastPath: false };
+    }
+    const payload = payloadFieldNames(model, data);
+    const classification = payload.length > 0
+        ? await ctx.provider.classifyFields(action, model.name, payload, ctx.context)
+        : {};
+    const allAlways = payload.every((f) => classification[f]?.access === 'always');
+    if (allAlways && !(0, authorization_1.isConditionalConstraint)(constraint) && relations.length === 0) {
+        return { select: {}, fastPath: true };
+    }
+    const scalarNames = new Set(metadata.get(model.name).scalarFields.map((f) => f.name));
+    const needed = new Set();
+    for (const field of metadata.get(model.name).scalarFields) {
+        if (field.isId || field.isUpdatedAt) {
+            needed.add(field.name);
+        }
+    }
+    for (const name of payload) {
+        needed.add(name);
+    }
+    for (const name of (0, readtree_1.constraintFieldNames)(constraint)) {
+        needed.add(name);
+    }
+    for (const name of payload) {
+        for (const required of classification[name]?.requires ?? []) {
+            needed.add(required);
+        }
+    }
+    const select = {};
+    for (const name of needed) {
+        if (scalarNames.has(name)) {
+            select[name] = true;
+        }
+    }
+    for (const relation of relations) {
+        const nestedSelect = modelScalarSelect(relation.target);
+        for (const payload of [...relation.createPayloads, ...relation.updatePayloads]) {
+            mergeSelect(nestedSelect, wideSelectWithMetadata(metadata, relation.target, payload));
+        }
+        select[relation.field.name] = { select: nestedSelect };
+    }
+    return { select, fastPath: false };
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@eleven-am/golem-core",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "jest"
+  },
+  "dependencies": {
+    "graphql-parse-resolve-info": "^4.14.1",
+    "pluralize": "^8.0.0"
+  },
+  "peerDependencies": {
+    "graphql": "^16.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.0",
+    "@types/pluralize": "^0.0.33",
+    "graphql": "^16.11.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.0"
+  },
+  "license": "GPL-3.0",
+  "author": "Roy OSSAI",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "description": "Golem core: datamodel, engine and policy kernel for schema-animated GraphQL backends",
+  "keywords": [
+    "graphql",
+    "prisma",
+    "crud",
+    "authorization",
+    "casl"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eleven-am/golem.git",
+    "directory": "packages/core"
+  }
+}