@eleven-am/golem-core 0.1.0

package/dist/schema.js

@@ -0,0 +1,580 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTimeScalar = void 0;
+exports.createGolemEngine = createGolemEngine;
+exports.subscribableModels = subscribableModels;
+exports.buildGolemSchema = buildGolemSchema;
+const graphql_1 = require("graphql");
+const errors_1 = require("./errors");
+const events_1 = require("./events");
+const extensions_1 = require("./extensions");
+const hooks_1 = require("./hooks");
+const inputs_1 = require("./inputs");
+const naming_1 = require("./naming");
+const operations_1 = require("./operations");
+const select_1 = require("./select");
+exports.DateTimeScalar = new graphql_1.GraphQLScalarType({
+    name: 'DateTime',
+    serialize: (value) => (value instanceof Date ? value.toISOString() : value),
+    parseValue: (value) => new Date(value),
+    parseLiteral: (ast) => (ast.kind === graphql_1.Kind.STRING ? new Date(ast.value) : null),
+});
+const SCALAR_MAP = {
+    String: graphql_1.GraphQLString,
+    Int: graphql_1.GraphQLInt,
+    Float: graphql_1.GraphQLFloat,
+    Boolean: graphql_1.GraphQLBoolean,
+    DateTime: exports.DateTimeScalar,
+};
+const ORDERED_OPERATORS = ['lt', 'lte', 'gt', 'gte'];
+const STRING_OPERATORS = ['contains', 'startsWith', 'endsWith'];
+function resolveModelSettings(model, config, defaults) {
+    const fieldNames = new Set(model.fields.map((f) => f.name));
+    const hidden = new Set(config?.hidden ?? []);
+    const immutable = new Set(config?.immutable ?? []);
+    for (const name of [...hidden, ...immutable]) {
+        if (!fieldNames.has(name)) {
+            throw new Error(`Unknown field ${name} in configuration for model ${model.name}`);
+        }
+    }
+    for (const field of model.fields) {
+        if (field.isId && hidden.has(field.name)) {
+            throw new Error(`Cannot hide primary key ${model.name}.${field.name}`);
+        }
+    }
+    const operations = config?.operations ?? defaults.operations ?? hooks_1.ALL_OPERATIONS;
+    for (const operation of operations) {
+        if (!hooks_1.ALL_OPERATIONS.includes(operation)) {
+            throw new Error(`Unknown operation ${operation} in configuration for model ${model.name}`);
+        }
+    }
+    return {
+        operations: new Set(operations),
+        hidden,
+        immutable,
+        maxTake: config?.maxTake ?? defaults.maxTake,
+        subscriptions: config?.subscriptions ?? defaults.subscriptions ?? false,
+    };
+}
+function wrapResolve(resolve) {
+    return async (root, args, ctx, info) => {
+        try {
+            return await resolve(root, args, ctx, info);
+        }
+        catch (error) {
+            if (error instanceof errors_1.GolemError) {
+                throw new graphql_1.GraphQLError(error.message, { extensions: { code: error.code } });
+            }
+            throw error;
+        }
+    };
+}
+function resolveGolem(options) {
+    const excluded = new Set(Object.entries(options.models ?? {})
+        .filter(([, value]) => value === false)
+        .map(([key]) => key));
+    const models = options.datamodel.models.filter((m) => !excluded.has(m.name));
+    const modelsByName = new Map(models.map((m) => [m.name, m]));
+    const settings = new Map(models.map((m) => [
+        m.name,
+        resolveModelSettings(m, (options.models?.[m.name] || undefined), options.defaults ?? {}),
+    ]));
+    const subscribable = new Set(models.filter((m) => settings.get(m.name).subscriptions).map((m) => m.name));
+    const takeLimits = new Map();
+    for (const [name, resolved] of settings) {
+        if (resolved.maxTake !== undefined) {
+            takeLimits.set(name, resolved.maxTake);
+        }
+    }
+    return { models, modelsByName, settings, subscribable, takeLimits };
+}
+function createGolemEngine(options) {
+    const { models, takeLimits } = resolveGolem(options);
+    return new operations_1.GolemEngine(options.client, models, {
+        hooks: options.hooks,
+        takeLimits,
+        authorization: options.authorization,
+        maxDepth: options.defaults?.maxDepth,
+        checkWriteResults: options.defaults?.checkWriteResults,
+        checkReadFields: options.defaults?.checkReadFields,
+    });
+}
+function subscribableModels(options) {
+    return resolveGolem({ ...options, client: {} }).subscribable;
+}
+function buildGolemSchema(options) {
+    const { models, modelsByName, settings, subscribable, takeLimits } = resolveGolem(options);
+    if (subscribable.size > 0 && !options.eventBus) {
+        throw new Error(`Subscriptions are enabled for ${[...subscribable].join(', ')} but no event bus was provided`);
+    }
+    const engine = options.engine ??
+        new operations_1.GolemEngine(options.client, models, {
+            hooks: options.hooks,
+            takeLimits,
+            authorization: options.authorization,
+            maxDepth: options.defaults?.maxDepth,
+            checkWriteResults: options.defaults?.checkWriteResults,
+            checkReadFields: options.defaults?.checkReadFields,
+        });
+    const hiddenFor = (name) => settings.get(name)?.hidden ?? new Set();
+    const immutableFor = (name) => settings.get(name)?.immutable ?? new Set();
+    const visibleFields = (model) => model.fields.filter((f) => !hiddenFor(model.name).has(f.name));
+    const computedSpecs = options.computedFields ?? [];
+    for (const spec of computedSpecs) {
+        const model = modelsByName.get(spec.model);
+        if (!model) {
+            throw new Error(`Computed field ${spec.name} targets unknown model ${spec.model}`);
+        }
+        if (model.fields.some((f) => f.name === spec.name)) {
+            throw new Error(`Computed field ${spec.model}.${spec.name} collides with an existing field`);
+        }
+        const fieldNames = new Set(model.fields.map((f) => f.name));
+        for (const required of spec.requires) {
+            if (!fieldNames.has(required)) {
+                throw new Error(`Computed field ${spec.model}.${spec.name} requires unknown field ${required}`);
+            }
+        }
+    }
+    const computedByModel = new Map();
+    for (const spec of computedSpecs) {
+        const list = computedByModel.get(spec.model) ?? [];
+        list.push(spec);
+        computedByModel.set(spec.model, list);
+    }
+    const computedRequires = (0, extensions_1.buildComputedRequiresMap)(computedSpecs);
+    const enumTypes = new Map(options.datamodel.enums.map((e) => [
+        e.name,
+        new graphql_1.GraphQLEnumType({
+            name: e.name,
+            values: Object.fromEntries(e.values.map((v) => [v, {}])),
+        }),
+    ]));
+    const sortOrder = new graphql_1.GraphQLEnumType({
+        name: 'SortOrder',
+        values: { asc: {}, desc: {} },
+    });
+    const batchPayload = new graphql_1.GraphQLObjectType({
+        name: 'BatchPayload',
+        fields: { count: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLInt) } },
+    });
+    const filterTypes = new Map();
+    function scalarType(model, field) {
+        const mapped = SCALAR_MAP[field.type];
+        if (!mapped) {
+            throw new Error(`Unsupported scalar type ${field.type} on ${model.name}.${field.name}`);
+        }
+        return mapped;
+    }
+    function filterTypeFor(name, type, operators) {
+        const existing = filterTypes.get(name);
+        if (existing) {
+            return existing;
+        }
+        const filter = new graphql_1.GraphQLInputObjectType({
+            name,
+            fields: () => {
+                const fields = {
+                    equals: { type },
+                    in: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(type)) },
+                    notIn: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(type)) },
+                    not: { type },
+                };
+                for (const op of operators) {
+                    fields[op] = { type };
+                }
+                return fields;
+            },
+        });
+        filterTypes.set(name, filter);
+        return filter;
+    }
+    function filterFor(model, field) {
+        if (field.kind === 'enum') {
+            const enumType = enumTypes.get(field.type);
+            if (!enumType) {
+                throw new Error(`Unknown enum ${field.type} on ${model.name}.${field.name}`);
+            }
+            return filterTypeFor(`${field.type}EnumFilter`, enumType, []);
+        }
+        const type = scalarType(model, field);
+        if (field.type === 'String') {
+            return filterTypeFor('StringFilter', type, [...ORDERED_OPERATORS, ...STRING_OPERATORS]);
+        }
+        if (field.type === 'Boolean') {
+            return filterTypeFor('BoolFilter', type, []);
+        }
+        return filterTypeFor(`${field.type}Filter`, type, ORDERED_OPERATORS);
+    }
+    const objectTypes = new Map();
+    const whereInputs = new Map();
+    const whereUniqueInputs = new Map();
+    const orderByInputs = new Map();
+    for (const model of models) {
+        objectTypes.set(model.name, new graphql_1.GraphQLObjectType({
+            name: model.name,
+            fields: () => {
+                const fields = {};
+                for (const field of visibleFields(model)) {
+                    if (field.kind === 'object') {
+                        const target = objectTypes.get(field.type);
+                        if (!target) {
+                            continue;
+                        }
+                        const type = field.isList
+                            ? new graphql_1.GraphQLNonNull(new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(target)))
+                            : target;
+                        fields[field.name] = { type };
+                    }
+                    else {
+                        const base = field.kind === 'enum' ? enumTypes.get(field.type) : scalarType(model, field);
+                        fields[field.name] = {
+                            type: field.isRequired ? new graphql_1.GraphQLNonNull(base) : base,
+                        };
+                    }
+                }
+                for (const spec of computedByModel.get(model.name) ?? []) {
+                    fields[spec.name] = {
+                        type: resolveTypeRef(spec.type, outputTypeByName),
+                        resolve: wrapResolve((parent, _args, ctx, info) => spec.resolve(parent, ctx, info)),
+                    };
+                }
+                return fields;
+            },
+        }));
+        whereInputs.set(model.name, new graphql_1.GraphQLInputObjectType({
+            name: `${model.name}WhereInput`,
+            fields: () => {
+                const self = whereInputs.get(model.name);
+                const fields = {
+                    AND: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(self)) },
+                    OR: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(self)) },
+                    NOT: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(self)) },
+                };
+                for (const field of visibleFields(model)) {
+                    if (field.kind === 'object' || field.isList) {
+                        continue;
+                    }
+                    fields[field.name] = { type: filterFor(model, field) };
+                }
+                return fields;
+            },
+        }));
+        whereUniqueInputs.set(model.name, new graphql_1.GraphQLInputObjectType({
+            name: `${model.name}WhereUniqueInput`,
+            fields: () => {
+                const fields = {};
+                for (const field of visibleFields(model)) {
+                    if (field.kind === 'scalar' && (field.isId || field.isUnique)) {
+                        fields[field.name] = { type: scalarType(model, field) };
+                    }
+                }
+                return fields;
+            },
+        }));
+        orderByInputs.set(model.name, new graphql_1.GraphQLInputObjectType({
+            name: `${model.name}OrderByInput`,
+            fields: () => {
+                const fields = {};
+                for (const field of visibleFields(model)) {
+                    if (field.kind === 'object' || field.isList) {
+                        continue;
+                    }
+                    fields[field.name] = { type: sortOrder };
+                }
+                return fields;
+            },
+        }));
+    }
+    const inputs = new inputs_1.InputTypeRegistry({
+        modelsByName,
+        enumTypes,
+        whereUniqueInputs,
+        scalarType,
+        hiddenFor,
+        immutableFor,
+    });
+    const namedScalars = {
+        ...SCALAR_MAP,
+        ID: graphql_1.GraphQLID,
+    };
+    function resolveTypeRef(ref, lookup) {
+        const trimmed = ref.trim();
+        if (trimmed.endsWith('!')) {
+            return new graphql_1.GraphQLNonNull(resolveTypeRef(trimmed.slice(0, -1), lookup));
+        }
+        if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+            return new graphql_1.GraphQLList(resolveTypeRef(trimmed.slice(1, -1), lookup));
+        }
+        const named = lookup(trimmed);
+        if (!named) {
+            throw new Error(`Unknown type ${trimmed} in extension type reference`);
+        }
+        return named;
+    }
+    function outputTypeByName(name) {
+        if (name === 'BatchPayload') {
+            return batchPayload;
+        }
+        return namedScalars[name] ?? enumTypes.get(name) ?? objectTypes.get(name);
+    }
+    function inputTypeByName(name) {
+        const direct = namedScalars[name] ?? enumTypes.get(name) ?? filterTypes.get(name) ?? inputs.find(name);
+        if (direct) {
+            return direct;
+        }
+        const suffixes = [
+            ['WhereUniqueInput', (m) => whereUniqueInputs.get(m.name)],
+            ['WhereInput', (m) => whereInputs.get(m.name)],
+            ['OrderByInput', (m) => orderByInputs.get(m.name)],
+            ['CreateInput', (m) => inputs.createInput(m)],
+            ['UpdateManyInput', (m) => inputs.updateManyInput(m)],
+            ['UpdateInput', (m) => inputs.updateInput(m)],
+        ];
+        for (const [suffix, get] of suffixes) {
+            if (name.endsWith(suffix)) {
+                const model = modelsByName.get(name.slice(0, -suffix.length));
+                if (model) {
+                    return get(model);
+                }
+            }
+        }
+        return undefined;
+    }
+    const queryFields = {};
+    const mutationFields = {};
+    const subscriptionFields = {};
+    const golemEventType = new graphql_1.GraphQLEnumType({
+        name: 'GolemEventType',
+        values: { CREATED: {}, UPDATED: {}, DELETED: {} },
+    });
+    for (const model of models) {
+        const objectType = objectTypes.get(model.name);
+        const whereInput = whereInputs.get(model.name);
+        const whereUniqueInput = whereUniqueInputs.get(model.name);
+        const orderByInput = orderByInputs.get(model.name);
+        const operations = settings.get(model.name).operations;
+        if (operations.has('findOne')) {
+            queryFields[(0, naming_1.findOneFieldName)(model.name)] = {
+                type: objectType,
+                args: {
+                    where: { type: new graphql_1.GraphQLNonNull(whereUniqueInput) },
+                },
+                resolve: wrapResolve((_root, args, ctx, info) => engine.findOne({
+                    model: model.name,
+                    where: args.where,
+                    select: (0, select_1.buildSelect)(info, model, modelsByName, computedRequires),
+                    context: ctx,
+                })),
+            };
+        }
+        if (operations.has('findMany')) {
+            queryFields[(0, naming_1.findManyFieldName)(model.name)] = {
+                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(objectType))),
+                args: {
+                    where: { type: whereInput },
+                    orderBy: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(orderByInput)) },
+                    take: { type: graphql_1.GraphQLInt },
+                    skip: { type: graphql_1.GraphQLInt },
+                },
+                resolve: wrapResolve((_root, args, ctx, info) => engine.findMany({
+                    model: model.name,
+                    where: args.where ?? undefined,
+                    orderBy: args.orderBy ?? undefined,
+                    take: args.take ?? undefined,
+                    skip: args.skip ?? undefined,
+                    select: (0, select_1.buildSelect)(info, model, modelsByName, computedRequires),
+                    context: ctx,
+                })),
+            };
+        }
+        if (operations.has('create')) {
+            mutationFields[(0, naming_1.createFieldName)(model.name)] = {
+                type: new graphql_1.GraphQLNonNull(objectType),
+                args: {
+                    data: { type: new graphql_1.GraphQLNonNull(inputs.createInput(model)) },
+                },
+                resolve: wrapResolve((_root, args, ctx, info) => engine.create({
+                    model: model.name,
+                    data: args.data,
+                    select: (0, select_1.buildSelect)(info, model, modelsByName, computedRequires),
+                    context: ctx,
+                })),
+            };
+        }
+        if (operations.has('update')) {
+            mutationFields[(0, naming_1.updateFieldName)(model.name)] = {
+                type: new graphql_1.GraphQLNonNull(objectType),
+                args: {
+                    where: { type: new graphql_1.GraphQLNonNull(whereUniqueInput) },
+                    data: { type: new graphql_1.GraphQLNonNull(inputs.updateInput(model)) },
+                },
+                resolve: wrapResolve((_root, args, ctx, info) => engine.update({
+                    model: model.name,
+                    where: args.where,
+                    data: args.data,
+                    select: (0, select_1.buildSelect)(info, model, modelsByName, computedRequires),
+                    context: ctx,
+                })),
+            };
+        }
+        if (operations.has('delete')) {
+            mutationFields[(0, naming_1.deleteFieldName)(model.name)] = {
+                type: new graphql_1.GraphQLNonNull(objectType),
+                args: {
+                    where: { type: new graphql_1.GraphQLNonNull(whereUniqueInput) },
+                },
+                resolve: wrapResolve((_root, args, ctx, info) => engine.delete({
+                    model: model.name,
+                    where: args.where,
+                    select: (0, select_1.buildSelect)(info, model, modelsByName, computedRequires),
+                    context: ctx,
+                })),
+            };
+        }
+        if (operations.has('updateMany')) {
+            mutationFields[(0, naming_1.updateManyFieldName)(model.name)] = {
+                type: new graphql_1.GraphQLNonNull(batchPayload),
+                args: {
+                    where: { type: whereInput },
+                    data: { type: new graphql_1.GraphQLNonNull(inputs.updateManyInput(model)) },
+                },
+                resolve: wrapResolve((_root, args, ctx) => engine.updateMany({
+                    model: model.name,
+                    where: args.where ?? undefined,
+                    data: args.data,
+                    context: ctx,
+                })),
+            };
+        }
+        if (operations.has('deleteMany')) {
+            mutationFields[(0, naming_1.deleteManyFieldName)(model.name)] = {
+                type: new graphql_1.GraphQLNonNull(batchPayload),
+                args: {
+                    where: { type: whereInput },
+                },
+                resolve: wrapResolve((_root, args, ctx) => engine.deleteMany({
+                    model: model.name,
+                    where: args.where ?? undefined,
+                    context: ctx,
+                })),
+            };
+        }
+        if (subscribable.has(model.name)) {
+            const eventBus = options.eventBus;
+            const pkField = model.fields.find((f) => f.isId);
+            if (!pkField) {
+                throw new Error(`Model ${model.name} has no primary key field and cannot be subscribable`);
+            }
+            const eventTypeName = `${model.name}Event`;
+            const eventType = new graphql_1.GraphQLObjectType({
+                name: eventTypeName,
+                fields: {
+                    type: { type: new graphql_1.GraphQLNonNull(golemEventType) },
+                    id: { type: new graphql_1.GraphQLNonNull(scalarType(model, pkField)) },
+                    entity: { type: objectType },
+                },
+            });
+            subscriptionFields[(0, naming_1.eventsFieldName)(model.name)] = {
+                type: new graphql_1.GraphQLNonNull(eventType),
+                args: {
+                    where: { type: whereInput },
+                },
+                subscribe: async function* (_root, args, ctx, info) {
+                    const authz = options.authorization;
+                    const eventContext = () => (authz ? authz.freshContext?.(ctx) ?? ctx : undefined);
+                    if (authz) {
+                        await authz.authorize('read', model.name, eventContext());
+                    }
+                    const entitySelect = (0, select_1.buildEventEntitySelect)(info, eventTypeName, model, modelsByName, computedRequires);
+                    for await (const payload of eventBus.iterate((0, events_1.eventTopic)(model.name))) {
+                        if (payload.type === 'DELETED') {
+                            // A deleted row can no longer be queried safely. Filtered deletion events are
+                            // therefore suppressed, and authorized subscriptions require a pre-delete
+                            // snapshot that passes a fresh instance check.
+                            if (args.where)
+                                continue;
+                            if (authz) {
+                                if (!payload.entity || !authz.check)
+                                    continue;
+                                try {
+                                    const allowed = await authz.check('read', model.name, payload.entity, eventContext());
+                                    if (!allowed)
+                                        continue;
+                                }
+                                catch (error) {
+                                    if (error instanceof errors_1.GolemError &&
+                                        (error.code === 'FORBIDDEN' || error.code === 'UNAUTHENTICATED'))
+                                        continue;
+                                    throw error;
+                                }
+                            }
+                            yield { type: payload.type, id: payload.id, entity: null };
+                            continue;
+                        }
+                        if (!args.where && !entitySelect && !authz) {
+                            yield { type: payload.type, id: payload.id, entity: null };
+                            continue;
+                        }
+                        const where = args.where
+                            ? { AND: [{ [pkField.name]: payload.id }, args.where] }
+                            : { [pkField.name]: payload.id };
+                        let entity;
+                        try {
+                            entity = await engine.findFirst({
+                                model: model.name,
+                                where,
+                                select: entitySelect ?? (0, select_1.primaryKeySelect)(model),
+                                context: eventContext(),
+                            });
+                        }
+                        catch (error) {
+                            if (error instanceof errors_1.GolemError &&
+                                (error.code === 'FORBIDDEN' || error.code === 'UNAUTHENTICATED')) {
+                                continue;
+                            }
+                            throw error;
+                        }
+                        if (!entity && (args.where || authz)) {
+                            continue;
+                        }
+                        yield { type: payload.type, id: payload.id, entity: entitySelect ? entity : null };
+                    }
+                },
+                resolve: (payload) => payload,
+            };
+        }
+    }
+    for (const spec of options.customOperations ?? []) {
+        const target = spec.kind === 'query' ? queryFields : mutationFields;
+        if (target[spec.name]) {
+            throw new Error(`Custom ${spec.kind} ${spec.name} collides with an existing field`);
+        }
+        const args = {};
+        for (const [argName, argRef] of Object.entries(spec.args ?? {})) {
+            args[argName] = { type: resolveTypeRef(argRef, inputTypeByName) };
+        }
+        target[spec.name] = {
+            type: resolveTypeRef(spec.type, outputTypeByName),
+            args,
+            resolve: wrapResolve((_root, resolvedArgs, ctx, info) => spec.resolve(resolvedArgs, ctx, info)),
+        };
+    }
+    return new graphql_1.GraphQLSchema({
+        query: new graphql_1.GraphQLObjectType({
+            name: 'Query',
+            fields: queryFields,
+        }),
+        mutation: Object.keys(mutationFields).length > 0
+            ? new graphql_1.GraphQLObjectType({
+                name: 'Mutation',
+                fields: mutationFields,
+            })
+            : undefined,
+        subscription: Object.keys(subscriptionFields).length > 0
+            ? new graphql_1.GraphQLObjectType({
+                name: 'Subscription',
+                fields: subscriptionFields,
+            })
+            : undefined,
+    });
+}

package/dist/select.d.ts

@@ -0,0 +1,15 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { DatamodelModel } from './datamodel';
+import { ComputedRequiresMap } from './extensions';
+export interface PrismaSelectRelation {
+    select?: PrismaSelect;
+    include?: PrismaSelect;
+    where?: unknown;
+    [key: string]: unknown;
+}
+export type PrismaSelect = {
+    [field: string]: boolean | PrismaSelectRelation;
+};
+export declare function primaryKeySelect(model: DatamodelModel): PrismaSelect;
+export declare function buildSelect(info: GraphQLResolveInfo, model: DatamodelModel, modelsByName: Map<string, DatamodelModel>, computed?: ComputedRequiresMap): PrismaSelect;
+export declare function buildEventEntitySelect(info: GraphQLResolveInfo, eventTypeName: string, model: DatamodelModel, modelsByName: Map<string, DatamodelModel>, computed?: ComputedRequiresMap): PrismaSelect | null;

package/dist/select.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primaryKeySelect = primaryKeySelect;
+exports.buildSelect = buildSelect;
+exports.buildEventEntitySelect = buildEventEntitySelect;
+const graphql_parse_resolve_info_1 = require("graphql-parse-resolve-info");
+function primaryKeySelect(model) {
+    const select = {};
+    for (const field of model.fields) {
+        if (field.isId) {
+            select[field.name] = true;
+        }
+    }
+    if (Object.keys(select).length === 0) {
+        throw new Error(`Model ${model.name} has no primary key field to select`);
+    }
+    return select;
+}
+function selectFromFields(fields, model, modelsByName, computed) {
+    const select = {};
+    const modelComputed = computed?.get(model.name);
+    for (const key of Object.keys(fields)) {
+        const tree = fields[key];
+        const field = model.fields.find((f) => f.name === tree.name);
+        if (!field) {
+            const requires = modelComputed?.get(tree.name);
+            if (requires) {
+                for (const column of requires) {
+                    select[column] = true;
+                }
+            }
+            continue;
+        }
+        if (field.kind === 'object') {
+            const target = modelsByName.get(field.type);
+            if (!target) {
+                continue;
+            }
+            select[field.name] = {
+                select: selectFromFields(tree.fieldsByTypeName[target.name] ?? {}, target, modelsByName, computed),
+            };
+        }
+        else {
+            select[field.name] = true;
+        }
+    }
+    if (Object.keys(select).length === 0) {
+        return primaryKeySelect(model);
+    }
+    return select;
+}
+function buildSelect(info, model, modelsByName, computed) {
+    const tree = (0, graphql_parse_resolve_info_1.parseResolveInfo)(info);
+    if (!tree) {
+        return primaryKeySelect(model);
+    }
+    return selectFromFields(tree.fieldsByTypeName[model.name] ?? {}, model, modelsByName, computed);
+}
+function buildEventEntitySelect(info, eventTypeName, model, modelsByName, computed) {
+    const tree = (0, graphql_parse_resolve_info_1.parseResolveInfo)(info);
+    const eventFields = tree?.fieldsByTypeName[eventTypeName] ?? {};
+    const entityTree = Object.values(eventFields).find((f) => f.name === 'entity');
+    if (!entityTree) {
+        return null;
+    }
+    return selectFromFields(entityTree.fieldsByTypeName[model.name] ?? {}, model, modelsByName, computed);
+}

package/dist/testing.d.ts

@@ -0,0 +1,2 @@
+import { DatamodelField } from './datamodel';
+export declare function field(overrides: Partial<DatamodelField> & Pick<DatamodelField, 'name' | 'type'>): DatamodelField;

package/dist/testing.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.field = field;
+function field(overrides) {
+    return {
+        kind: 'scalar',
+        isList: false,
+        isRequired: true,
+        isUnique: false,
+        isId: false,
+        hasDefaultValue: false,
+        isReadOnly: false,
+        isUpdatedAt: false,
+        ...overrides,
+    };
+}