@eleven-am/golem-core 0.1.0

package/dist/naming.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lcFirst = lcFirst;
+exports.ucFirst = ucFirst;
+exports.findOneFieldName = findOneFieldName;
+exports.findManyFieldName = findManyFieldName;
+exports.createFieldName = createFieldName;
+exports.updateFieldName = updateFieldName;
+exports.deleteFieldName = deleteFieldName;
+exports.updateManyFieldName = updateManyFieldName;
+exports.deleteManyFieldName = deleteManyFieldName;
+exports.eventsFieldName = eventsFieldName;
+const pluralize_1 = __importDefault(require("pluralize"));
+function lcFirst(name) {
+    return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function ucFirst(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function pluralOrList(name) {
+    const plural = (0, pluralize_1.default)(name);
+    return plural === name ? `${name}List` : plural;
+}
+function findOneFieldName(model) {
+    return lcFirst(model);
+}
+function findManyFieldName(model) {
+    return pluralOrList(lcFirst(model));
+}
+function createFieldName(model) {
+    return `create${model}`;
+}
+function updateFieldName(model) {
+    return `update${model}`;
+}
+function deleteFieldName(model) {
+    return `delete${model}`;
+}
+function updateManyFieldName(model) {
+    return `updateMany${pluralOrList(model)}`;
+}
+function deleteManyFieldName(model) {
+    return `deleteMany${pluralOrList(model)}`;
+}
+function eventsFieldName(model) {
+    return `${lcFirst(model)}Events`;
+}

package/dist/nested-writes.d.ts

@@ -0,0 +1,24 @@
+import { GolemAction } from './authorization';
+import { DatamodelField, DatamodelModel } from './datamodel';
+import { ModelMetadataIndex } from './model-meta';
+export type NestedWriteKind = 'create' | 'createMany' | 'connectOrCreate' | 'connect' | 'disconnect' | 'set' | 'update' | 'updateMany' | 'upsert' | 'delete' | 'deleteMany';
+export interface NestedWriteOperation {
+    readonly kind: NestedWriteKind;
+    readonly payloads: readonly unknown[];
+    readonly createPayloads: readonly Record<string, unknown>[];
+    readonly updatePayloads: readonly Record<string, unknown>[];
+}
+export interface NestedRelationWritePlan {
+    readonly field: DatamodelField;
+    readonly target: DatamodelModel;
+    readonly operations: readonly NestedWriteOperation[];
+    readonly createPayloads: readonly Record<string, unknown>[];
+    readonly updatePayloads: readonly Record<string, unknown>[];
+    readonly modelActions: ReadonlySet<GolemAction>;
+    readonly addedActions: ReadonlySet<GolemAction>;
+    readonly removedActions: ReadonlySet<GolemAction>;
+    readonly retainedActions: ReadonlySet<GolemAction>;
+}
+export declare function planNestedWrites(metadata: ModelMetadataIndex, model: DatamodelModel, data: Record<string, unknown>): readonly NestedRelationWritePlan[];
+/** Identifies no-op retained updates so they still receive an instance authorization check. */
+export declare function nestedPlanTargetsRow(plan: NestedRelationWritePlan, row: Record<string, unknown>): boolean;

package/dist/nested-writes.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planNestedWrites = planNestedWrites;
+exports.nestedPlanTargetsRow = nestedPlanTargetsRow;
+const KINDS = new Set([
+    'create',
+    'createMany',
+    'connectOrCreate',
+    'connect',
+    'disconnect',
+    'set',
+    'update',
+    'updateMany',
+    'upsert',
+    'delete',
+    'deleteMany',
+]);
+function array(value) {
+    return Array.isArray(value) ? value : [value];
+}
+function record(value) {
+    return value && typeof value === 'object' ? value : undefined;
+}
+function operation(kind, value) {
+    const payloads = array(value);
+    const createPayloads = [];
+    const updatePayloads = [];
+    for (const payload of payloads) {
+        const item = record(payload);
+        if (!item)
+            continue;
+        if (kind === 'create')
+            createPayloads.push(item);
+        if (kind === 'createMany') {
+            for (const data of array(item.data)) {
+                const candidate = record(data);
+                if (candidate)
+                    createPayloads.push(candidate);
+            }
+        }
+        if (kind === 'connectOrCreate') {
+            const candidate = record(item.create);
+            if (candidate)
+                createPayloads.push(candidate);
+        }
+        if (kind === 'update' || kind === 'updateMany') {
+            const candidate = record(item.data) ?? item;
+            if (candidate)
+                updatePayloads.push(candidate);
+        }
+        if (kind === 'upsert') {
+            const created = record(item.create);
+            const updated = record(item.update);
+            if (created)
+                createPayloads.push(created);
+            if (updated)
+                updatePayloads.push(updated);
+        }
+    }
+    return Object.freeze({ kind, payloads, createPayloads, updatePayloads });
+}
+function actionSets(operations) {
+    const model = new Set();
+    const added = new Set();
+    const removed = new Set();
+    const retained = new Set();
+    for (const { kind } of operations) {
+        if (kind === 'create' || kind === 'createMany') {
+            model.add('create');
+            added.add('create');
+        }
+        else if (kind === 'connectOrCreate') {
+            model.add('create');
+            model.add('update');
+            added.add('create');
+            added.add('update');
+        }
+        else if (kind === 'connect') {
+            model.add('update');
+            added.add('update');
+        }
+        else if (kind === 'disconnect' || kind === 'set') {
+            model.add('update');
+            removed.add('update');
+            if (kind === 'set')
+                added.add('update');
+        }
+        else if (kind === 'update' || kind === 'updateMany') {
+            model.add('update');
+            retained.add('update');
+        }
+        else if (kind === 'upsert') {
+            model.add('create');
+            model.add('update');
+            added.add('create');
+            retained.add('update');
+        }
+        else if (kind === 'delete' || kind === 'deleteMany') {
+            model.add('delete');
+            removed.add('delete');
+        }
+    }
+    return { model, added, removed, retained };
+}
+function planNestedWrites(metadata, model, data) {
+    const plans = [];
+    const relations = metadata.get(model.name)?.relations ?? model.fields.filter((f) => f.kind === 'object');
+    for (const field of relations) {
+        const envelope = record(data[field.name]);
+        const target = metadata.get(field.type)?.model;
+        if (!envelope || !target)
+            continue;
+        const operations = Object.entries(envelope)
+            .filter(([key, value]) => KINDS.has(key) && value !== undefined)
+            .map(([key, value]) => operation(key, value));
+        if (operations.length === 0)
+            continue;
+        const sets = actionSets(operations);
+        plans.push(Object.freeze({
+            field,
+            target,
+            operations,
+            createPayloads: operations.flatMap((entry) => entry.createPayloads),
+            updatePayloads: operations.flatMap((entry) => entry.updatePayloads),
+            modelActions: sets.model,
+            addedActions: sets.added,
+            removedActions: sets.removed,
+            retainedActions: sets.retained,
+        }));
+    }
+    return Object.freeze(plans);
+}
+function compareFilter(value, filter) {
+    if (value instanceof Date || filter instanceof Date) {
+        const left = value instanceof Date ? value.getTime() : value;
+        const right = filter instanceof Date ? filter.getTime() : filter;
+        return Object.is(left, right);
+    }
+    if (!filter || typeof filter !== 'object' || Array.isArray(filter))
+        return Object.is(value, filter);
+    const operations = filter;
+    return Object.entries(operations).every(([operator, expected]) => {
+        if (operator === 'equals')
+            return Object.is(value, expected);
+        if (operator === 'in')
+            return Array.isArray(expected) && expected.some((item) => Object.is(value, item));
+        if (operator === 'notIn')
+            return Array.isArray(expected) && expected.every((item) => !Object.is(value, item));
+        if (operator === 'not')
+            return !compareFilter(value, expected);
+        if (operator === 'lt')
+            return value < expected;
+        if (operator === 'lte')
+            return value <= expected;
+        if (operator === 'gt')
+            return value > expected;
+        if (operator === 'gte')
+            return value >= expected;
+        if (operator === 'contains')
+            return typeof value === 'string' && value.includes(String(expected));
+        if (operator === 'startsWith')
+            return typeof value === 'string' && value.startsWith(String(expected));
+        if (operator === 'endsWith')
+            return typeof value === 'string' && value.endsWith(String(expected));
+        return false;
+    });
+}
+function matchesWhere(row, where) {
+    if (!where || typeof where !== 'object' || Array.isArray(where))
+        return true;
+    return Object.entries(where).every(([key, expected]) => {
+        const branches = Array.isArray(expected) ? expected : [expected];
+        if (key === 'AND')
+            return branches.every((branch) => matchesWhere(row, branch));
+        if (key === 'OR')
+            return branches.some((branch) => matchesWhere(row, branch));
+        if (key === 'NOT')
+            return branches.every((branch) => !matchesWhere(row, branch));
+        return compareFilter(row[key], expected);
+    });
+}
+/** Identifies no-op retained updates so they still receive an instance authorization check. */
+function nestedPlanTargetsRow(plan, row) {
+    return plan.operations.some((operation) => {
+        if (operation.kind !== 'update' && operation.kind !== 'updateMany' && operation.kind !== 'upsert') {
+            return false;
+        }
+        return operation.payloads.some((payload) => {
+            const item = record(payload);
+            return item ? matchesWhere(row, item.where) : false;
+        });
+    });
+}

package/dist/operations.d.ts

@@ -0,0 +1,122 @@
+import { AuthorizationProvider } from './authorization';
+import { DatamodelModel } from './datamodel';
+import { HookRegistry } from './hooks';
+import { PrismaSelect } from './select';
+export interface FindOneRequest {
+    context?: unknown;
+    model: string;
+    where: unknown;
+    select?: PrismaSelect;
+    include?: unknown;
+}
+export interface FindManyRequest {
+    context?: unknown;
+    model: string;
+    where?: unknown;
+    orderBy?: unknown;
+    take?: number;
+    skip?: number;
+    cursor?: unknown;
+    distinct?: unknown;
+    select?: PrismaSelect;
+    include?: unknown;
+}
+export interface CreateRequest {
+    context?: unknown;
+    model: string;
+    data: unknown;
+    select?: PrismaSelect;
+    include?: unknown;
+}
+export interface UpdateRequest {
+    context?: unknown;
+    model: string;
+    where: unknown;
+    data: unknown;
+    select?: PrismaSelect;
+    include?: unknown;
+}
+export interface UpdateManyRequest {
+    context?: unknown;
+    model: string;
+    where?: unknown;
+    data: unknown;
+}
+export interface DeleteRequest {
+    context?: unknown;
+    model: string;
+    where: unknown;
+    select?: PrismaSelect;
+    include?: unknown;
+}
+export interface DeleteManyRequest {
+    context?: unknown;
+    model: string;
+    where?: unknown;
+}
+export interface FindFirstRequest {
+    context?: unknown;
+    model: string;
+    where?: unknown;
+    select?: PrismaSelect;
+    include?: unknown;
+}
+export interface UpsertRequest {
+    context?: unknown;
+    model: string;
+    where: unknown;
+    create: unknown;
+    update: unknown;
+    select?: PrismaSelect;
+    include?: unknown;
+}
+export interface GolemEngineOptions {
+    hooks?: HookRegistry;
+    takeLimits?: ReadonlyMap<string, number>;
+    authorization?: AuthorizationProvider;
+    maxDepth?: number;
+    checkWriteResults?: boolean;
+    checkReadFields?: boolean;
+}
+export interface GolemEngineRef {
+    current?: GolemEngine;
+}
+export interface BatchResult {
+    count: number;
+}
+export declare class GolemEngine {
+    private readonly client;
+    private readonly modelsByName;
+    private readonly metadata;
+    private readonly hooks?;
+    private readonly takeLimits;
+    private readonly authorization?;
+    private readonly maxDepth;
+    private readonly checkWriteResults;
+    private readonly checkReadFields;
+    private readonly authorizationSessions;
+    constructor(client: Record<string, any>, models: readonly DatamodelModel[], options?: GolemEngineOptions);
+    private verifyContext;
+    private pkOf;
+    private prepareRead;
+    private finishRead;
+    private enforced;
+    private constraintFor;
+    private authorizeNestedWrites;
+    private walkNestedWrites;
+    private resolveConstrainedTarget;
+    private runBefore;
+    private runAfter;
+    private enforceTakeLimit;
+    private delegate;
+    private run;
+    findOne(request: FindOneRequest): Promise<unknown>;
+    findMany(request: FindManyRequest): Promise<unknown[]>;
+    findFirst(request: FindFirstRequest): Promise<unknown>;
+    create(request: CreateRequest): Promise<unknown>;
+    update(request: UpdateRequest): Promise<unknown>;
+    updateMany(request: UpdateManyRequest): Promise<BatchResult>;
+    delete(request: DeleteRequest): Promise<unknown>;
+    upsert(request: UpsertRequest): Promise<unknown>;
+    deleteMany(request: DeleteManyRequest): Promise<BatchResult>;
+}