@eleven-am/golem-core 0.1.0

package/dist/authorization.d.ts

@@ -0,0 +1,16 @@
+export type GolemAction = 'read' | 'create' | 'update' | 'delete';
+export interface AuthorizationProvider {
+    authorize(action: GolemAction, model: string, context: unknown): Promise<void>;
+    constrain(action: GolemAction, model: string, context: unknown): Promise<unknown>;
+    check?(action: GolemAction, model: string, entity: unknown, context: unknown): Promise<boolean>;
+    checkField?(action: GolemAction, model: string, entity: unknown, field: string, context: unknown): Promise<boolean>;
+    classifyFields?(action: GolemAction, model: string, fields: readonly string[], context: unknown): Promise<Record<string, FieldClassification>>;
+    freshContext?(context: unknown): unknown;
+}
+export interface FieldClassification {
+    access: 'always' | 'conditional' | 'never';
+    requires?: readonly string[];
+}
+export declare function isConditionalConstraint(constraint: unknown): boolean;
+export declare const NESTED_WRITE_ACTIONS: Record<string, GolemAction>;
+export declare function mergeConstraint(where: unknown, constraint: unknown): unknown;

package/dist/authorization.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NESTED_WRITE_ACTIONS = void 0;
+exports.isConditionalConstraint = isConditionalConstraint;
+exports.mergeConstraint = mergeConstraint;
+function isConditionalConstraint(constraint) {
+    return (constraint !== undefined &&
+        constraint !== null &&
+        typeof constraint === 'object' &&
+        Object.keys(constraint).length > 0);
+}
+exports.NESTED_WRITE_ACTIONS = {
+    create: 'create',
+    createMany: 'create',
+    connectOrCreate: 'create',
+    connect: 'update',
+    disconnect: 'update',
+    set: 'update',
+    update: 'update',
+    updateMany: 'update',
+    upsert: 'update',
+    delete: 'delete',
+    deleteMany: 'delete',
+};
+function mergeConstraint(where, constraint) {
+    if (constraint === undefined) {
+        return where;
+    }
+    if (where === undefined || where === null) {
+        return constraint;
+    }
+    return { AND: [where, constraint] };
+}

package/dist/concurrency.d.ts

@@ -0,0 +1,2 @@
+/** Runs independent policy checks concurrently while reporting the earliest input-order failure. */
+export declare function runPolicyChecks(checks: readonly (() => Promise<void>)[], concurrency?: number): Promise<void>;

package/dist/concurrency.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPolicyChecks = runPolicyChecks;
+const DEFAULT_POLICY_CONCURRENCY = 8;
+/** Runs independent policy checks concurrently while reporting the earliest input-order failure. */
+async function runPolicyChecks(checks, concurrency = DEFAULT_POLICY_CONCURRENCY) {
+    const width = Math.max(1, Math.floor(concurrency));
+    for (let offset = 0; offset < checks.length; offset += width) {
+        const settled = await Promise.allSettled(checks.slice(offset, offset + width).map((check) => check()));
+        for (const result of settled) {
+            if (result.status === 'rejected') {
+                throw result.reason;
+            }
+        }
+    }
+}

package/dist/datamodel.d.ts

@@ -0,0 +1,48 @@
+import { GolemOperation } from './hooks';
+export type DatamodelFieldKind = 'scalar' | 'object' | 'enum';
+export interface DatamodelField {
+    name: string;
+    kind: DatamodelFieldKind;
+    type: string;
+    isList: boolean;
+    isRequired: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    hasDefaultValue: boolean;
+    isReadOnly: boolean;
+    isUpdatedAt: boolean;
+    relationName?: string;
+    relationFromFields?: readonly string[];
+    relationToFields?: readonly string[];
+}
+export interface DatamodelModel {
+    name: string;
+    fields: readonly DatamodelField[];
+}
+export interface DatamodelEnum {
+    name: string;
+    values: readonly string[];
+}
+export interface DatamodelDocument<TModels = Record<string, string>> {
+    models: readonly DatamodelModel[];
+    enums: readonly DatamodelEnum[];
+    __models?: TModels;
+}
+export interface ModelConfig<TField extends string = string> {
+    subscriptions?: boolean;
+    operations?: readonly GolemOperation[];
+    hidden?: readonly TField[];
+    immutable?: readonly TField[];
+    maxTake?: number;
+}
+export type ModelsConfig<TModels> = {
+    [K in keyof TModels]?: false | ModelConfig<Extract<TModels[K], string>>;
+};
+export interface GolemDefaults {
+    subscriptions?: boolean;
+    operations?: readonly GolemOperation[];
+    maxTake?: number;
+    maxDepth?: number;
+    checkWriteResults?: boolean;
+    checkReadFields?: boolean;
+}

package/dist/datamodel.js

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

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+export type GolemErrorCode = 'NOT_FOUND' | 'CONFLICT' | 'BAD_USER_INPUT' | 'UNAUTHENTICATED' | 'FORBIDDEN';
+export declare class GolemError extends Error {
+    readonly code: GolemErrorCode;
+    constructor(message: string, code: GolemErrorCode);
+}
+export declare class GolemNotFoundError extends GolemError {
+    constructor(message: string);
+}
+export declare class GolemConflictError extends GolemError {
+    constructor(message: string);
+}
+export declare class GolemValidationError extends GolemError {
+    constructor(message: string);
+}
+export declare class GolemUnauthorizedError extends GolemError {
+    constructor(message: string);
+}
+export declare class GolemForbiddenError extends GolemError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GolemForbiddenError = exports.GolemUnauthorizedError = exports.GolemValidationError = exports.GolemConflictError = exports.GolemNotFoundError = exports.GolemError = void 0;
+class GolemError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = new.target.name;
+    }
+}
+exports.GolemError = GolemError;
+class GolemNotFoundError extends GolemError {
+    constructor(message) {
+        super(message, 'NOT_FOUND');
+    }
+}
+exports.GolemNotFoundError = GolemNotFoundError;
+class GolemConflictError extends GolemError {
+    constructor(message) {
+        super(message, 'CONFLICT');
+    }
+}
+exports.GolemConflictError = GolemConflictError;
+class GolemValidationError extends GolemError {
+    constructor(message) {
+        super(message, 'BAD_USER_INPUT');
+    }
+}
+exports.GolemValidationError = GolemValidationError;
+class GolemUnauthorizedError extends GolemError {
+    constructor(message) {
+        super(message, 'UNAUTHENTICATED');
+    }
+}
+exports.GolemUnauthorizedError = GolemUnauthorizedError;
+class GolemForbiddenError extends GolemError {
+    constructor(message) {
+        super(message, 'FORBIDDEN');
+    }
+}
+exports.GolemForbiddenError = GolemForbiddenError;

package/dist/event-buffer.d.ts

@@ -0,0 +1,5 @@
+export interface BufferedEvent {
+    publish(): Promise<void>;
+}
+export declare function bufferEvent(event: BufferedEvent): boolean;
+export declare function withBufferedEvents<T>(fn: () => Promise<T>): Promise<T>;

package/dist/event-buffer.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferEvent = bufferEvent;
+exports.withBufferedEvents = withBufferedEvents;
+const node_async_hooks_1 = require("node:async_hooks");
+const storage = new node_async_hooks_1.AsyncLocalStorage();
+function bufferEvent(event) {
+    const store = storage.getStore();
+    if (!store) {
+        return false;
+    }
+    store.buffer.push(event);
+    return true;
+}
+async function withBufferedEvents(fn) {
+    const store = { buffer: [] };
+    const result = await storage.run(store, fn);
+    for (const event of store.buffer) {
+        await event.publish();
+    }
+    return result;
+}

package/dist/events.d.ts

@@ -0,0 +1,13 @@
+export type GolemEventType = 'CREATED' | 'UPDATED' | 'DELETED';
+export interface GolemEventPayload {
+    type: GolemEventType;
+    model: string;
+    id: string | number;
+    /** Pre-delete snapshot used only to authorize deletion delivery; never exposed as event.entity. */
+    entity?: Record<string, unknown>;
+}
+export interface GolemEventBus {
+    publish(topic: string, payload: GolemEventPayload): Promise<void>;
+    iterate(topic: string): AsyncIterableIterator<GolemEventPayload>;
+}
+export declare function eventTopic(model: string): string;

package/dist/events.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventTopic = eventTopic;
+function eventTopic(model) {
+    return `golem.${model}`;
+}

package/dist/extensions.d.ts

@@ -0,0 +1,17 @@
+import { GraphQLResolveInfo } from 'graphql';
+export interface ComputedFieldSpec {
+    model: string;
+    name: string;
+    type: string;
+    requires: readonly string[];
+    resolve: (parent: any, ctx: unknown, info: GraphQLResolveInfo) => unknown;
+}
+export interface CustomOperationSpec {
+    kind: 'query' | 'mutation';
+    name: string;
+    type: string;
+    args?: Record<string, string>;
+    resolve: (args: any, ctx: unknown, info: GraphQLResolveInfo) => unknown;
+}
+export type ComputedRequiresMap = ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>;
+export declare function buildComputedRequiresMap(specs: readonly ComputedFieldSpec[]): ComputedRequiresMap;

package/dist/extensions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComputedRequiresMap = buildComputedRequiresMap;
+function buildComputedRequiresMap(specs) {
+    const map = new Map();
+    for (const spec of specs) {
+        const perModel = map.get(spec.model) ?? new Map();
+        perModel.set(spec.name, spec.requires);
+        map.set(spec.model, perModel);
+    }
+    return map;
+}

package/dist/hooks.d.ts

@@ -0,0 +1,18 @@
+export type GolemOperation = 'findOne' | 'findMany' | 'create' | 'update' | 'delete' | 'updateMany' | 'deleteMany';
+export declare const ALL_OPERATIONS: readonly GolemOperation[];
+export interface GolemHookContext {
+    model: string;
+    operation: GolemOperation;
+    context?: unknown;
+}
+export type BeforeHook<TRequest = any> = (request: TRequest, ctx: GolemHookContext) => TRequest | void | Promise<TRequest | void>;
+export type AfterHook = (result: unknown, ctx: GolemHookContext) => void | Promise<void>;
+export declare class HookRegistry {
+    private readonly beforeHooks;
+    private readonly afterHooks;
+    private static key;
+    registerBefore(model: string, operation: GolemOperation, hook: BeforeHook): void;
+    registerAfter(model: string, operation: GolemOperation, hook: AfterHook): void;
+    beforeFor(model: string, operation: GolemOperation): readonly BeforeHook[];
+    afterFor(model: string, operation: GolemOperation): readonly AfterHook[];
+}

package/dist/hooks.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookRegistry = exports.ALL_OPERATIONS = void 0;
+exports.ALL_OPERATIONS = [
+    'findOne',
+    'findMany',
+    'create',
+    'update',
+    'delete',
+    'updateMany',
+    'deleteMany',
+];
+class HookRegistry {
+    beforeHooks = new Map();
+    afterHooks = new Map();
+    static key(model, operation) {
+        return `${model}.${operation}`;
+    }
+    registerBefore(model, operation, hook) {
+        const key = HookRegistry.key(model, operation);
+        const hooks = this.beforeHooks.get(key) ?? [];
+        hooks.push(hook);
+        this.beforeHooks.set(key, hooks);
+    }
+    registerAfter(model, operation, hook) {
+        const key = HookRegistry.key(model, operation);
+        const hooks = this.afterHooks.get(key) ?? [];
+        hooks.push(hook);
+        this.afterHooks.set(key, hooks);
+    }
+    beforeFor(model, operation) {
+        return this.beforeHooks.get(HookRegistry.key(model, operation)) ?? [];
+    }
+    afterFor(model, operation) {
+        return this.afterHooks.get(HookRegistry.key(model, operation)) ?? [];
+    }
+}
+exports.HookRegistry = HookRegistry;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from './authorization';
+export * from './datamodel';
+export * from './event-buffer';
+export * from './errors';
+export * from './events';
+export * from './extensions';
+export * from './hooks';
+export * from './model-meta';
+export * from './nested-writes';
+export * from './publisher';
+export * from './naming';
+export * from './operations';
+export * from './schema';
+export * from './select';
+export * from './typemap';
+export * from './verify';

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./authorization"), exports);
+__exportStar(require("./datamodel"), exports);
+__exportStar(require("./event-buffer"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./extensions"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./model-meta"), exports);
+__exportStar(require("./nested-writes"), exports);
+__exportStar(require("./publisher"), exports);
+__exportStar(require("./naming"), exports);
+__exportStar(require("./operations"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./select"), exports);
+__exportStar(require("./typemap"), exports);
+__exportStar(require("./verify"), exports);

package/dist/inputs.d.ts

@@ -0,0 +1,29 @@
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType } from 'graphql';
+import { DatamodelField, DatamodelModel } from './datamodel';
+export interface InputBuilderContext {
+    modelsByName: Map<string, DatamodelModel>;
+    enumTypes: Map<string, GraphQLEnumType>;
+    whereUniqueInputs: Map<string, GraphQLInputObjectType>;
+    scalarType: (model: DatamodelModel, field: DatamodelField) => GraphQLScalarType;
+    hiddenFor: (model: string) => ReadonlySet<string>;
+    immutableFor: (model: string) => ReadonlySet<string>;
+}
+export declare class InputTypeRegistry {
+    private readonly ctx;
+    private readonly types;
+    constructor(ctx: InputBuilderContext);
+    private memo;
+    find(name: string): GraphQLInputObjectType | undefined;
+    private backRelationField;
+    private writableFields;
+    private updatableFields;
+    private scalarInputField;
+    private createRequired;
+    createInput(model: DatamodelModel): GraphQLInputObjectType;
+    private createWithoutInput;
+    private buildCreateInput;
+    private nestedCreateInput;
+    updateInput(model: DatamodelModel): GraphQLInputObjectType;
+    private nestedUpdateInput;
+    updateManyInput(model: DatamodelModel): GraphQLInputObjectType;
+}

package/dist/inputs.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputTypeRegistry = void 0;
+const graphql_1 = require("graphql");
+const naming_1 = require("./naming");
+class InputTypeRegistry {
+    ctx;
+    types = new Map();
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    memo(name, factory) {
+        const existing = this.types.get(name);
+        if (existing) {
+            return existing;
+        }
+        const created = factory();
+        this.types.set(name, created);
+        return created;
+    }
+    find(name) {
+        return this.types.get(name);
+    }
+    backRelationField(model, field) {
+        const target = this.ctx.modelsByName.get(field.type);
+        if (!target) {
+            throw new Error(`Relation ${model.name}.${field.name} targets unknown model ${field.type}`);
+        }
+        const back = target.fields.find((f) => f.kind === 'object' && f.relationName === field.relationName && f.type === model.name);
+        if (!back) {
+            throw new Error(`Relation ${model.name}.${field.name} has no back relation on ${field.type}`);
+        }
+        return back;
+    }
+    writableFields(model, excludeRelation) {
+        const hidden = this.ctx.hiddenFor(model.name);
+        return model.fields.filter((field) => {
+            if (field.isReadOnly || hidden.has(field.name)) {
+                return false;
+            }
+            if (excludeRelation && field.name === excludeRelation.name) {
+                return false;
+            }
+            return true;
+        });
+    }
+    updatableFields(model) {
+        const immutable = this.ctx.immutableFor(model.name);
+        return this.writableFields(model).filter((field) => !immutable.has(field.name));
+    }
+    scalarInputField(model, field, required) {
+        const base = field.kind === 'enum' ? this.ctx.enumTypes.get(field.type) : this.ctx.scalarType(model, field);
+        return { type: required ? new graphql_1.GraphQLNonNull(base) : base };
+    }
+    createRequired(field) {
+        return field.isRequired && !field.hasDefaultValue && !field.isUpdatedAt;
+    }
+    createInput(model) {
+        return this.memo(`${model.name}CreateInput`, () => this.buildCreateInput(`${model.name}CreateInput`, model, undefined));
+    }
+    createWithoutInput(model, excludeRelation) {
+        const name = `${model.name}CreateWithout${(0, naming_1.ucFirst)(excludeRelation.name)}Input`;
+        return this.memo(name, () => this.buildCreateInput(name, model, excludeRelation));
+    }
+    buildCreateInput(name, model, excludeRelation) {
+        return new graphql_1.GraphQLInputObjectType({
+            name,
+            fields: () => {
+                const fields = {};
+                for (const field of this.writableFields(model, excludeRelation)) {
+                    if (field.kind === 'object') {
+                        if (!this.ctx.modelsByName.has(field.type)) {
+                            continue;
+                        }
+                        fields[field.name] = { type: this.nestedCreateInput(model, field) };
+                    }
+                    else {
+                        fields[field.name] = this.scalarInputField(model, field, this.createRequired(field));
+                    }
+                }
+                return fields;
+            },
+        });
+    }
+    nestedCreateInput(model, field) {
+        const target = this.ctx.modelsByName.get(field.type);
+        const back = this.backRelationField(model, field);
+        const whereUnique = this.ctx.whereUniqueInputs.get(target.name);
+        if (field.isList) {
+            const envelope = this.memo(`${target.name}CreateNestedManyWithout${(0, naming_1.ucFirst)(back.name)}Input`, () => new graphql_1.GraphQLInputObjectType({
+                name: `${target.name}CreateNestedManyWithout${(0, naming_1.ucFirst)(back.name)}Input`,
+                fields: () => ({
+                    create: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(this.createWithoutInput(target, back))) },
+                    connect: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(whereUnique)) },
+                }),
+            }));
+            return envelope;
+        }
+        const envelope = this.memo(`${target.name}CreateNestedOneWithout${(0, naming_1.ucFirst)(back.name)}Input`, () => new graphql_1.GraphQLInputObjectType({
+            name: `${target.name}CreateNestedOneWithout${(0, naming_1.ucFirst)(back.name)}Input`,
+            fields: () => ({
+                create: { type: this.createWithoutInput(target, back) },
+                connect: { type: whereUnique },
+            }),
+        }));
+        return field.isRequired ? new graphql_1.GraphQLNonNull(envelope) : envelope;
+    }
+    updateInput(model) {
+        return this.memo(`${model.name}UpdateInput`, () => new graphql_1.GraphQLInputObjectType({
+            name: `${model.name}UpdateInput`,
+            fields: () => {
+                const fields = {};
+                for (const field of this.updatableFields(model)) {
+                    if (field.kind === 'object') {
+                        if (!this.ctx.modelsByName.has(field.type)) {
+                            continue;
+                        }
+                        fields[field.name] = { type: this.nestedUpdateInput(field) };
+                    }
+                    else {
+                        fields[field.name] = this.scalarInputField(model, field, false);
+                    }
+                }
+                return fields;
+            },
+        }));
+    }
+    nestedUpdateInput(field) {
+        const target = this.ctx.modelsByName.get(field.type);
+        const whereUnique = this.ctx.whereUniqueInputs.get(target.name);
+        if (field.isList) {
+            return this.memo(`${target.name}UpdateManyRelationInput`, () => new graphql_1.GraphQLInputObjectType({
+                name: `${target.name}UpdateManyRelationInput`,
+                fields: () => ({
+                    connect: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(whereUnique)) },
+                    disconnect: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(whereUnique)) },
+                }),
+            }));
+        }
+        if (field.isRequired) {
+            return this.memo(`${target.name}UpdateOneRequiredRelationInput`, () => new graphql_1.GraphQLInputObjectType({
+                name: `${target.name}UpdateOneRequiredRelationInput`,
+                fields: () => ({
+                    connect: { type: whereUnique },
+                }),
+            }));
+        }
+        return this.memo(`${target.name}UpdateOneRelationInput`, () => new graphql_1.GraphQLInputObjectType({
+            name: `${target.name}UpdateOneRelationInput`,
+            fields: () => ({
+                connect: { type: whereUnique },
+                disconnect: { type: graphql_1.GraphQLBoolean },
+            }),
+        }));
+    }
+    updateManyInput(model) {
+        return this.memo(`${model.name}UpdateManyInput`, () => new graphql_1.GraphQLInputObjectType({
+            name: `${model.name}UpdateManyInput`,
+            fields: () => {
+                const fields = {};
+                for (const field of this.updatableFields(model)) {
+                    if (field.kind === 'object') {
+                        continue;
+                    }
+                    fields[field.name] = this.scalarInputField(model, field, false);
+                }
+                return fields;
+            },
+        }));
+    }
+}
+exports.InputTypeRegistry = InputTypeRegistry;

package/dist/model-meta.d.ts

@@ -0,0 +1,10 @@
+import { DatamodelField, DatamodelModel } from './datamodel';
+export interface ModelMetadata {
+    readonly model: DatamodelModel;
+    readonly fieldsByName: ReadonlyMap<string, DatamodelField>;
+    readonly scalarFields: readonly DatamodelField[];
+    readonly relations: readonly DatamodelField[];
+    readonly primaryKey?: DatamodelField;
+}
+export type ModelMetadataIndex = ReadonlyMap<string, ModelMetadata>;
+export declare function buildModelMetadata(models: readonly DatamodelModel[]): ModelMetadataIndex;

package/dist/model-meta.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModelMetadata = buildModelMetadata;
+class ImmutableMap {
+    #data;
+    constructor(entries) {
+        this.#data = new Map(entries);
+        Object.freeze(this);
+    }
+    get size() { return this.#data.size; }
+    get(key) { return this.#data.get(key); }
+    has(key) { return this.#data.has(key); }
+    entries() { return this.#data.entries(); }
+    keys() { return this.#data.keys(); }
+    values() { return this.#data.values(); }
+    [Symbol.iterator]() { return this.#data[Symbol.iterator](); }
+    forEach(callbackfn, thisArg) {
+        this.#data.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
+    }
+}
+function buildModelMetadata(models) {
+    const entries = models.map((model) => {
+        const scalarFields = Object.freeze(model.fields.filter((field) => field.kind !== 'object'));
+        const relations = Object.freeze(model.fields.filter((field) => field.kind === 'object'));
+        return [
+            model.name,
+            Object.freeze({
+                model,
+                fieldsByName: new ImmutableMap(model.fields.map((field) => [field.name, field])),
+                scalarFields,
+                relations,
+                primaryKey: scalarFields.find((field) => field.isId),
+            }),
+        ];
+    });
+    return new ImmutableMap(entries);
+}

package/dist/naming.d.ts

@@ -0,0 +1,10 @@
+export declare function lcFirst(name: string): string;
+export declare function ucFirst(name: string): string;
+export declare function findOneFieldName(model: string): string;
+export declare function findManyFieldName(model: string): string;
+export declare function createFieldName(model: string): string;
+export declare function updateFieldName(model: string): string;
+export declare function deleteFieldName(model: string): string;
+export declare function updateManyFieldName(model: string): string;
+export declare function deleteManyFieldName(model: string): string;
+export declare function eventsFieldName(model: string): string;