Mini Object-relational Mapper III

Requirements

• Export MiniORM as named and default. new MiniORM(modelNames, relations = {}) accepts unique nonempty model-name strings. model(name) returns a stable delegate for a registered model; unknown models throw Error. Invalid/duplicate model names throw TypeError.
• Delegates expose synchronous create({ data }), findUnique({ where: { id } }), findMany({ where? } = {}), update({ where: { id }, data }), and delete({ where: { id } }). Records are flat own-enumerable string fields containing null, strings, booleans, or finite numbers. Data must be a plain object; reject unsupported record field values with TypeError. Extended query filters are defined below.
• create generates per-model positive integer IDs starting at 1 when data has no own id. Explicit positive safe-integer IDs are allowed, must be unique, and advance the next generated ID beyond them. Deleted IDs are not automatically reused. Invalid IDs throw TypeError; duplicate IDs throw Error.
• Keep create, findUnique, update, and delete behavior from the first version, including copied records, atomic invalid writes, immutable IDs, and independent models. Extend findMany({ where?, orderBy? } = {}).
• A field condition is a scalar or a nonempty operator object. Support equals (Object.is), in (scalar array), gt/gte/lt/lte (finite numeric operands; only numeric fields match), and contains (case-sensitive substring on string fields). Multiple operators on a field are ANDed; absent fields never match field conditions.
• Combine own fields with AND: Filter[], OR: Filter[], and NOT: Filter. Every own clause is ANDed. Empty AND is true, empty OR is false, and {} matches all records. These three uppercase names are reserved in filters. Reject malformed filters and unknown operators with TypeError, even when no records exist.
• orderBy is an array of { field, direction: asc | desc }. Compare fields in listed order; equal keys retain insertion order. Ascending type order is missing, null, boolean, number, string; within types use false before true, numeric order, and JavaScript string comparison. Descending reverses this order. Empty ordering preserves insertion order. Validate ordering before querying.
• Add read options select?: Record<string,boolean> and include?: Record<string,boolean | {select?: Record<string,boolean>}> to findMany and findUnique. Projection includes exactly own fields marked true, in selection key order. An omitted select includes all scalar fields; {} selects none. Unknown selected fields are omitted. false fields are excluded.
• The constructor’s relations object maps source model names to relation names and descriptors {model, localKey, foreignKey, many}. Validate configured source/target model names, string join keys, and boolean many; invalid configuration throws TypeError. Snapshot configuration so later caller changes cannot alter it.
• include true expands that configured relation; false omits it. Join by Object.is between own localKey and foreignKey fields. Missing local keys match nothing. many true returns copied target records in insertion order; many false returns the first matching copied record or null. Relations stay live after creates, updates, and deletes.
• An included {select} projects target scalar fields with the same rules. Root select may be combined with include; includes are added after projection and overwrite an identically named scalar output field. Includes never change root filtering or sorting. Only one relation level is supported; nested includes and relation filters are excluded.
• Validate select/include shapes and unknown relation names before reading rows, including empty stores and missing findUnique targets. Invalid masks or include options throw TypeError. Do not expose storage through returned root or included records; safely define special property names. CRUD remains unchanged and returns full flat records. No async storage, SQL, schema-level foreign-key enforcement, pagination, or transactions are required.

Examples

Input: users.findUnique({where:{id:1},select:{name:true},include:{posts:{select:{title:true}}}})
Output: {name:"Ada",posts:[{title:"One"},{title:"Two"}]}

Input: posts.findUnique({where:{id:3},include:{author:true}})
Output: {id:3,title:"Orphan",authorId:9,author:null}