@bairock/lenz 0.0.15 → 0.0.16

package/dist/engine/generators/GenerateRuntimeQuery.js

@@ -0,0 +1,427 @@
+export function generateRuntimeQuery() {
+    return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { ObjectId, Filter, UpdateFilter } from 'mongodb'
+import type { WhereInput, QueryOptions, SelectInput } from '../types'
+import { PaginationHelper } from './pagination'
+
+export class QueryBuilder {
+  static buildWhere<T>(where: WhereInput<T>): Filter<any> {
+    const filter: Filter<any> = {}
+
+    for (const [key, value] of Object.entries(where || {})) {
+      if (key === 'id') {
+        if (typeof value === 'object' && value !== null) {
+          this.applyOperators(filter, '_id', value)
+        } else {
+          filter._id = this.normalizeId(value)
+        }
+      } else if (key === 'search') {
+        if (typeof value === 'string' && value.length > 0) {
+          filter.$text = { $search: value }
+        }
+      } else if (key === 'AND') {
+        if (value !== null && typeof value === 'object') {
+          const conditions = Array.isArray(value) ? value : [value]
+          if (conditions.length > 0) {
+            filter.$and = conditions.map(cond => this.buildWhere(cond))
+          }
+        }
+      } else if (key === 'OR') {
+        if (value !== null && typeof value === 'object') {
+          const conditions = Array.isArray(value) ? value : [value]
+          if (conditions.length > 0) {
+            filter.$or = conditions.map(cond => this.buildWhere(cond))
+          }
+        }
+      } else if (key === 'NOT') {
+        if (value !== null && typeof value === 'object') {
+          const conditions = Array.isArray(value) ? value : [value]
+          if (conditions.length > 0) {
+            filter.$nor = conditions.map(cond => this.buildWhere(cond))
+          }
+        }
+      } else if (typeof value === 'object' && value !== null) {
+        this.applyOperators(filter, key, value)
+      } else {
+        filter[key] = value
+      }
+    }
+
+    return filter
+  }
+
+  static buildCursorCondition(
+    cursor: string | ObjectId,
+    orderBy: any = { _id: 'asc' }
+  ): Filter<any> {
+    const cursorId = typeof cursor === 'string'
+      ? PaginationHelper.parseCursor(cursor)
+      : cursor.toString()
+
+    const isDesc = (v: any) => v === 'desc' || v === -1;
+    const isAsc = (v: any) => v === 'asc' || v === 1 || v === undefined;
+
+    if (orderBy._id || (!Object.keys(orderBy).length)) {
+      const cursorObjectId = (() => { try { return new ObjectId(cursorId); } catch { return cursorId; } })();
+      const dir = isDesc(orderBy._id) ? '$lt' : '$gt';
+      return { _id: { [dir]: cursorObjectId } }
+    }
+
+    const orderField = Object.keys(orderBy)[0]
+    const orderDirection = orderBy[orderField]
+
+    return {
+      [orderField]: isDesc(orderDirection)
+        ? { $lt: cursorId }
+        : { $gt: cursorId }
+    }
+  }
+
+  static buildProjection<T>(
+    select: SelectInput | undefined,
+    hiddenFields: string[] = [],
+    omit?: SelectInput,
+    fieldMapping?: Record<string, string>
+  ): any {
+    const mapField = (name: string): string => fieldMapping?.[name] || name;
+
+    if (omit && !select) {
+      const projection: any = {};
+      for (const [key, value] of Object.entries(omit)) {
+        if (value) projection[mapField(key)] = 0;
+      }
+      hiddenFields.forEach(field => { projection[mapField(field)] = 0; });
+      return Object.keys(projection).length > 0 ? projection : undefined;
+    }
+
+    if (!select) {
+      if (hiddenFields.length === 0) return undefined;
+      const projection: any = {};
+      hiddenFields.forEach(field => {
+        projection[mapField(field)] = 0;
+      });
+      return projection;
+    }
+
+    const projection: any = {};
+    const processSelect = (sel: SelectInput, prefix = '') => {
+      for (const [key, value] of Object.entries(sel)) {
+        const mappedKey = prefix ? key : mapField(key);
+        const fullPath = prefix ? \`\${prefix}.\${key}\` : mappedKey;
+
+        if (typeof value === 'boolean') {
+          projection[fullPath] = value ? 1 : 0;
+        } else {
+          processSelect(value, fullPath);
+        }
+      }
+    };
+
+    processSelect(select);
+
+    // Don't add hiddenFields as 0 here — MongoDB rejects mixed 1/0 projections (error 31253).
+    // With inclusion projection, hidden fields not in select are automatically excluded.
+
+    return projection;
+  }
+
+  static buildOptions<T>(options: QueryOptions<T>, hiddenFields: string[] = [], fieldMapping?: Record<string, string>): any {
+    const result: any = {}
+
+    if (options.skip !== undefined) result.skip = options.skip
+    if (options.take !== undefined) result.limit = options.take
+
+    if (options.orderBy) {
+      result.sort = this.buildSort(options.orderBy)
+    }
+
+    if (options.session) {
+      result.session = options.session
+    }
+
+    const projection = this.buildProjection(options.select, hiddenFields, options.omit, fieldMapping)
+    if (projection) {
+      result.projection = projection
+    }
+
+    return result
+  }
+
+  static buildSort(orderBy: any): any {
+    if (Array.isArray(orderBy)) {
+      return orderBy.reduce((acc, curr) => ({ ...acc, ...this.buildSort(curr) }), {})
+    }
+
+    const sort: any = {}
+    for (const [field, direction] of Object.entries(orderBy)) {
+      const mongoField = field === 'id' ? '_id' : field
+      if (direction === 'asc' || direction === 1) {
+        sort[mongoField] = 1
+      } else if (direction === 'desc' || direction === -1) {
+        sort[mongoField] = -1
+      }
+    }
+    return sort
+  }
+
+  private static applyOperators(filter: any, field: string, operators: any): void {
+    let targetField = field;
+    const pathArr = operators.path;
+    if (Array.isArray(pathArr) && pathArr.length > 0) {
+      targetField = pathArr.reduce((acc: string, p: string) => \`\${acc}.\${p}\`, field);
+    }
+
+    const mode = operators.mode;
+    const isInsensitive = mode === 'insensitive';
+
+    const mongoOperators: Record<string, string> = {
+      equals: '$eq',
+      not: '$ne',
+      in: '$in',
+      notIn: '$nin',
+      lt: '$lt',
+      lte: '$lte',
+      gt: '$gt',
+      gte: '$gte',
+      contains: '$regex',
+      startsWith: '$regex',
+      endsWith: '$regex'
+    }
+
+    for (const [op, value] of Object.entries(operators)) {
+      if (op === 'path') continue;
+      if (op === 'mode') continue;
+
+      if (op === 'string_contains') {
+        filter[targetField] = { $regex: String(value).replace(/[.*+?^\${}()|[\]\\\\]/g, '\\\\$&'), $options: 'i' };
+        continue;
+      }
+      if (op === 'string_starts_with') {
+        filter[targetField] = { $regex: \`^\${String(value).replace(/[.*+?^\${}()|[\]\\\\]/g, '\\\\$&')}\`, $options: 'i' };
+        continue;
+      }
+      if (op === 'string_ends_with') {
+        filter[targetField] = { $regex: \`\${String(value).replace(/[.*+?^\${}()|[\]\\\\]/g, '\\\\$&')}\$\`, $options: 'i' };
+        continue;
+      }
+
+      if (op === 'has') {
+        filter[targetField] = { $elemMatch: { $eq: value } };
+        continue;
+      }
+      if (op === 'hasEvery') {
+        if (Array.isArray(value)) {
+          filter[targetField] = { $all: value };
+        }
+        continue;
+      }
+      if (op === 'hasSome') {
+        if (Array.isArray(value)) {
+          filter[targetField] = { $in: value };
+        }
+        continue;
+      }
+      if (op === 'isEmpty') {
+        if (value) {
+          filter[targetField] = { $size: 0 };
+        } else {
+          // $not cannot contain $size — use $nor instead
+          filter[targetField] = { $nor: [{ $exists: false }, { $size: 0 }] };
+        }
+        continue;
+      }
+      if (op === 'equals') {
+        if (Array.isArray(value)) {
+          filter[targetField] = { $eq: value };
+          continue;
+        }
+        // Non-array values fall through to generic $eq handler below
+      }
+
+      // Geo-spatial operators (MongoDB)
+      if (op === 'near' || op === 'nearSphere') {
+        const mongoOp = op === 'near' ? '$near' : '$nearSphere';
+        if (value && typeof value === 'object') {
+          const geoValue: any = {};
+          if (value.type && value.coordinates) {
+            geoValue.$geometry = { type: value.type, coordinates: value.coordinates };
+          }
+          if (value.maxDistance !== undefined) geoValue.$maxDistance = value.maxDistance;
+          if (value.minDistance !== undefined) geoValue.$minDistance = value.minDistance;
+          filter[targetField] = { [mongoOp]: geoValue };
+        }
+        continue;
+      }
+      if (op === 'geoWithin') {
+        if (value && typeof value === 'object') {
+          filter[targetField] = { $geoWithin: value };
+        }
+        continue;
+      }
+      if (op === 'geoIntersects') {
+        if (value && typeof value === 'object' && value.$geometry) {
+          filter[targetField] = { $geoIntersects: { $geometry: value.$geometry } };
+        }
+        continue;
+      }
+      if (op === 'geoContains') {
+        if (value && typeof value === 'object' && value.$geometry) {
+          filter[targetField] = { $geoContains: { $geometry: value.$geometry } };
+        }
+        continue;
+      }
+
+      if (op === 'array_contains') {
+        filter[targetField] = value;
+        continue;
+      }
+      if (op === 'array_starts_with') {
+        filter[targetField] = { $expr: { $eq: [{ $arrayElemAt: [{ $ifNull: ['$' + targetField, []] }, 0] }, value] } };
+        continue;
+      }
+      if (op === 'array_ends_with') {
+        filter[targetField] = { $expr: { $eq: [{ $arrayElemAt: [{ $ifNull: ['$' + targetField, []] }, -1] }, value] } };
+        continue;
+      }
+
+      const mongoOp = mongoOperators[op]
+
+      if (mongoOp) {
+        if (op === 'contains') {
+          filter[targetField] = { $regex: String(value).replace(/[.*+?^\${}()|[\]\\\\]/g, '\\\\$&'), $options: isInsensitive ? 'i' : '' }
+        } else if (op === 'startsWith') {
+          filter[targetField] = { $regex: \`^\${String(value).replace(/[.*+?^\${}()|[\]\\\\]/g, '\\\\$&')}\`, $options: isInsensitive ? 'i' : '' }
+        } else if (op === 'endsWith') {
+          filter[targetField] = { $regex: \`\${String(value).replace(/[.*+?^\${}()|[\]\\\\]/g, '\\\\$&')}\$\`, $options: isInsensitive ? 'i' : '' }
+        } else if (isInsensitive && (op === 'equals' || op === 'not')) {
+          const escapedValue = String(value).replace(/[.*+?^\${}()|[\]\\\\]/g, '\\\\$&');
+          if (op === 'equals') {
+            filter[targetField] = { $regex: new RegExp(\`^\${escapedValue}\$\`, 'i') };
+          } else {
+            filter[targetField] = { $not: { $regex: \`^\${escapedValue}\$\`, $options: 'i' } };
+          }
+        } else if (isInsensitive && (op === 'in' || op === 'notIn')) {
+          if (Array.isArray(value)) {
+            const regexes = value.map(v => new RegExp(\`^\${String(v).replace(/[.*+?^\${}()|[\]\\\\]/g, '\\\\$&')}\$\`, 'i'));
+            filter[targetField] = { [op === 'in' ? '$in' : '$nin']: regexes };
+          }
+        } else {
+          if (!filter[targetField]) filter[targetField] = {}
+          const normalizedValue = targetField === '_id' ? this.normalizeId(value) : value
+          filter[targetField][mongoOp] = normalizedValue
+        }
+      }
+    }
+  }
+
+  static normalizeId(id: string | ObjectId | (string | ObjectId)[]): ObjectId | string | (ObjectId | string)[] {
+    try {
+      if (Array.isArray(id)) {
+        return id.map(item => this.normalizeId(item) as ObjectId | string)
+      }
+      if (typeof id === 'string' && /^[0-9a-fA-F]{24}$/.test(id)) {
+        return new ObjectId(id)
+      }
+      return id
+    } catch {
+      return id
+    }
+  }
+
+  static buildUpdate(data: any): UpdateFilter<any> {
+    const update: UpdateFilter<any> = {}
+
+    const setOperations: any = {}
+    const mongoOperators: any = {}
+
+    const atomicOperators = ['increment', 'decrement', 'multiply', 'divide'];
+    const arrayOperators = ['push', 'pull', 'addToSet', 'pop', 'pullAll'];
+    const operatorMap: Record<string, string> = {
+      push: '$push',
+      pull: '$pull',
+      addToSet: '$addToSet',
+      pop: '$pop',
+      pullAll: '$pullAll'
+    };
+
+    for (const [key, value] of Object.entries(data)) {
+      if (key.startsWith('$')) {
+        mongoOperators[key] = value
+      } else {
+        if (typeof value === 'object' && value !== null) {
+          const keys = Object.keys(value)
+
+          // Atomic number operations: increment, decrement, multiply, divide
+          if (keys.every(k => atomicOperators.includes(k))) {
+            const inc: Record<string, number> = {};
+            const mul: Record<string, number> = {};
+            for (const op of keys) {
+              const opValue = value[op];
+              if (op === 'increment') { inc[key] = opValue; }
+              else if (op === 'decrement') { inc[key] = -opValue; }
+              else if (op === 'multiply') { mul[key] = opValue; }
+              else if (op === 'divide') { mul[key] = 1 / opValue; }
+            }
+            if (Object.keys(inc).length > 0) {
+              if (!mongoOperators.$inc) mongoOperators.$inc = {};
+              Object.assign(mongoOperators.$inc, inc);
+            }
+            if (Object.keys(mul).length > 0) {
+              if (!mongoOperators.$mul) mongoOperators.$mul = {};
+              Object.assign(mongoOperators.$mul, mul);
+            }
+            continue;
+          }
+
+          if (keys.length === 1 && arrayOperators.includes(keys[0])) {
+            const op = keys[0]
+            const opValue = value[op]
+
+            if (op === 'push' || op === 'addToSet') {
+              if (typeof opValue === 'object' && opValue !== null && Object.keys(opValue).length === 1 && opValue.each !== undefined) {
+                const mongoOp = operatorMap[op]
+                if (!mongoOperators[mongoOp]) {
+                  mongoOperators[mongoOp] = {}
+                }
+                mongoOperators[mongoOp][key] = { $each: opValue.each }
+                continue
+              }
+            }
+
+            const mongoOp = operatorMap[op]
+            if (!mongoOperators[mongoOp]) {
+              mongoOperators[mongoOp] = {}
+            }
+
+            // push, addToSet, pull — sub-ops ($each, $position, $in, etc.) need $ prefix for MongoDB
+            if (['push', 'addToSet', 'pull'].includes(op) && typeof opValue === 'object' && opValue !== null && !Array.isArray(opValue)) {
+              const prefixed: any = {};
+              for (const [k, v] of Object.entries(opValue)) {
+                prefixed[k.startsWith('$') ? k : '$' + k] = v;
+              }
+              mongoOperators[mongoOp][key] = prefixed;
+            } else {
+              mongoOperators[mongoOp][key] = opValue;
+            }
+            continue
+          }
+        }
+
+        setOperations[key] = value
+      }
+    }
+
+    if (Object.keys(setOperations).length > 0) {
+      update.$set = setOperations
+    }
+
+    Object.assign(update, mongoOperators)
+
+    return update
+  }
+}
+`;
+}
+//# sourceMappingURL=GenerateRuntimeQuery.js.map

package/dist/engine/generators/GenerateRuntimeQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenerateRuntimeQuery.js","sourceRoot":"","sources":["../../../src/engine/generators/GenerateRuntimeQuery.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,oBAAoB;IAChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuaV,CAAC;AACF,CAAC"}

package/dist/engine/generators/GenerateRuntimeRelations.d.ts

@@ -0,0 +1,2 @@
+export declare function generateRuntimeRelations(): string;
+//# sourceMappingURL=GenerateRuntimeRelations.d.ts.map

package/dist/engine/generators/GenerateRuntimeRelations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenerateRuntimeRelations.d.ts","sourceRoot":"","sources":["../../../src/engine/generators/GenerateRuntimeRelations.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,IAAI,MAAM,CAgIjD"}

package/dist/engine/generators/GenerateRuntimeRelations.js

@@ -0,0 +1,130 @@
+export function generateRuntimeRelations() {
+    return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { Db, ObjectId } from 'mongodb'
+import { QueryBuilder } from './query'
+
+export class RelationResolver {
+  static async resolveOneToOne(
+    db: Db,
+    sourceCollection: string,
+    targetCollection: string,
+    sourceId: string,
+    foreignKey: string
+  ): Promise<any> {
+    const collection = db.collection(targetCollection)
+    const id = QueryBuilder.normalizeId(sourceId)
+    return await collection.findOne({ [foreignKey]: id })
+  }
+
+  static async resolveOneToMany(
+    db: Db,
+    sourceCollection: string,
+    targetCollection: string,
+    sourceId: string,
+    foreignKey: string
+  ): Promise<any[]> {
+    const collection = db.collection(targetCollection)
+    const id = QueryBuilder.normalizeId(sourceId)
+    return await collection.find({ [foreignKey]: id }).toArray()
+  }
+
+  static async resolveManyToMany(
+    db: Db,
+    sourceCollection: string,
+    targetCollection: string,
+    joinCollection: string,
+    sourceField: string,
+    targetField: string,
+    sourceId: string,
+    where?: any,
+    orderBy?: any,
+    take?: number,
+    skip?: number,
+    select?: any
+  ): Promise<any[]> {
+    const joinCol = db.collection(joinCollection)
+    const targetCol = db.collection(targetCollection)
+
+    const connections = await joinCol.find({
+      [sourceField]: sourceId
+    }).toArray()
+
+    const targetIds = connections.map(c => c[targetField])
+
+    if (targetIds.length === 0) {
+      return []
+    }
+
+    let query: any = { _id: { $in: targetIds.map(id => {
+      try { return new ObjectId(id) } catch { return id }
+    }) } }
+
+    if (where && Object.keys(where).length > 0) {
+      query = { $and: [query, where] }
+    }
+
+    let cursor = targetCol.find(query)
+
+    if (orderBy) {
+      cursor = cursor.sort(orderBy)
+    }
+    if (skip !== undefined && skip !== null) {
+      cursor = cursor.skip(skip)
+    }
+    if (take !== undefined && take !== null) {
+      cursor = cursor.limit(take)
+    }
+    if (select) {
+      const projection = QueryBuilder.buildProjection(select, [])
+      if (projection) {
+        cursor = cursor.project(projection)
+      }
+    }
+
+    return await cursor.toArray()
+  }
+
+  static async countManyToMany(
+    db: Db,
+    joinCollection: string,
+    sourceField: string,
+    sourceId: string
+  ): Promise<number> {
+    const joinCol = db.collection(joinCollection)
+    return await joinCol.countDocuments({ [sourceField]: sourceId })
+  }
+
+  static formatDocument(doc: any): any {
+    if (!doc) return doc
+    const formatted = { ...doc }
+    if (formatted._id) {
+      formatted.id = formatted._id.toString()
+      delete formatted._id
+    }
+    // Convert BSON types to JS types (depth-first, recursing into arrays and nested objects)
+    for (const [key, val] of Object.entries(formatted)) {
+      if (Array.isArray(val)) {
+        formatted[key] = val.map(item =>
+          item !== null && typeof item === 'object' ? this.formatDocument(item) : item
+        );
+      } else if (val !== null && typeof val === 'object') {
+        if (val instanceof ObjectId || val._bsontype === 'ObjectId') {
+          formatted[key] = val.toString()
+        } else if (val._bsontype === 'Long') {
+          formatted[key] = val.toBigInt()
+        } else if (val._bsontype === 'Binary') {
+          formatted[key] = Buffer.from(val.buffer)
+        } else if (!(val instanceof Date) && !(val instanceof Buffer)) {
+          // Recurse into nested objects (embedded documents)
+          formatted[key] = this.formatDocument(val)
+        }
+      }
+    }
+    return formatted
+  }
+}
+`;
+}
+//# sourceMappingURL=GenerateRuntimeRelations.js.map

package/dist/engine/generators/GenerateRuntimeRelations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenerateRuntimeRelations.js","sourceRoot":"","sources":["../../../src/engine/generators/GenerateRuntimeRelations.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,wBAAwB;IACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8HV,CAAC;AACF,CAAC"}

package/dist/engine/generators/RuntimeGenerator.d.ts

@@ -0,0 +1,16 @@
+import { generateRuntimePagination } from './GenerateRuntimePagination.js';
+import { generateRuntimeErrors } from './GenerateRuntimeErrors.js';
+import { generateRuntimeLogger } from './GenerateRuntimeLogger.js';
+import { generateRuntimeIndex } from './GenerateRuntimeIndex.js';
+import { generateRuntimeQuery } from './GenerateRuntimeQuery.js';
+import { generateRuntimeRelations } from './GenerateRuntimeRelations.js';
+export { generateRuntimePagination, generateRuntimeErrors, generateRuntimeLogger, generateRuntimeIndex, generateRuntimeQuery, generateRuntimeRelations };
+export declare class RuntimeGenerator {
+    generateRuntimePagination(): string;
+    generateRuntimeErrors(): string;
+    generateRuntimeLogger(): string;
+    generateRuntimeIndex(): string;
+    generateRuntimeQuery(): string;
+    generateRuntimeRelations(): string;
+}
+//# sourceMappingURL=RuntimeGenerator.d.ts.map

package/dist/engine/generators/RuntimeGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeGenerator.d.ts","sourceRoot":"","sources":["../../../src/engine/generators/RuntimeGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACzB,CAAC;AAEF,qBAAa,gBAAgB;IAC3B,yBAAyB;IACzB,qBAAqB;IACrB,qBAAqB;IACrB,oBAAoB;IACpB,oBAAoB;IACpB,wBAAwB;CACzB"}

package/dist/engine/generators/RuntimeGenerator.js

@@ -0,0 +1,16 @@
+import { generateRuntimePagination } from './GenerateRuntimePagination.js';
+import { generateRuntimeErrors } from './GenerateRuntimeErrors.js';
+import { generateRuntimeLogger } from './GenerateRuntimeLogger.js';
+import { generateRuntimeIndex } from './GenerateRuntimeIndex.js';
+import { generateRuntimeQuery } from './GenerateRuntimeQuery.js';
+import { generateRuntimeRelations } from './GenerateRuntimeRelations.js';
+export { generateRuntimePagination, generateRuntimeErrors, generateRuntimeLogger, generateRuntimeIndex, generateRuntimeQuery, generateRuntimeRelations };
+export class RuntimeGenerator {
+    generateRuntimePagination() { return generateRuntimePagination(); }
+    generateRuntimeErrors() { return generateRuntimeErrors(); }
+    generateRuntimeLogger() { return generateRuntimeLogger(); }
+    generateRuntimeIndex() { return generateRuntimeIndex(); }
+    generateRuntimeQuery() { return generateRuntimeQuery(); }
+    generateRuntimeRelations() { return generateRuntimeRelations(); }
+}
+//# sourceMappingURL=RuntimeGenerator.js.map

package/dist/engine/generators/RuntimeGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeGenerator.js","sourceRoot":"","sources":["../../../src/engine/generators/RuntimeGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACzB,CAAC;AAEF,MAAM,OAAO,gBAAgB;IAC3B,yBAAyB,KAAK,OAAO,yBAAyB,EAAE,CAAC,CAAC,CAAC;IACnE,qBAAqB,KAAK,OAAO,qBAAqB,EAAE,CAAC,CAAC,CAAC;IAC3D,qBAAqB,KAAK,OAAO,qBAAqB,EAAE,CAAC,CAAC,CAAC;IAC3D,oBAAoB,KAAK,OAAO,oBAAoB,EAAE,CAAC,CAAC,CAAC;IACzD,oBAAoB,KAAK,OAAO,oBAAoB,EAAE,CAAC,CAAC,CAAC;IACzD,wBAAwB,KAAK,OAAO,wBAAwB,EAAE,CAAC,CAAC,CAAC;CAClE"}

package/dist/engine/generators/TypeFilterTypes.d.ts

@@ -0,0 +1,2 @@
+export declare function generateFilterTypes(): string;
+//# sourceMappingURL=TypeFilterTypes.d.ts.map

package/dist/engine/generators/TypeFilterTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeFilterTypes.d.ts","sourceRoot":"","sources":["../../../src/engine/generators/TypeFilterTypes.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,IAAI,MAAM,CA0N5C"}