@prisma/orm-family-mongo 0.16.0-dev.36

package/dist/index-Dv2PNMiG.d.mts

@@ -0,0 +1,53 @@
+import { JsonValue } from "@prisma/orm-framework/contract/types";
+import { Codec, CodecCallContext, CodecTrait } from "@prisma/orm-framework/components/codec";
+//#region ../../../2-mongo-family/1-foundation/mongo-codec/dist/index.d.mts
+//#region src/codecs.d.ts
+type MongoCodecTrait = CodecTrait;
+/**
+ * A codec for the Mongo target. Translates between an application value and the BSON-shaped wire form the Mongo driver exchanges, and between an application value and the JSON form stored in contract artifacts.
+ *
+ * Same shape as the framework codec base — see `Codec` in `@internal/framework-components/codec` for the contract. Codec-id-keyed static metadata (`traits`, `targetTypes`, `renderOutputType`) lives on the unified {@link import('@prisma/orm-framework/components/codec').CodecDescriptor}; Mongo's full migration to descriptor-side registration is tracked under TML-2324.
+ */
+interface MongoCodec<Id extends string = string, TTraits extends readonly MongoCodecTrait[] = readonly MongoCodecTrait[], TWire = unknown, TInput = unknown> extends Codec<Id, TTraits, TWire, TInput> {}
+/**
+ * Conditional bundle for `encodeJson`/`decodeJson`: when `TInput` is structurally assignable to `JsonValue` the identity defaults are sound and both fields are optional; otherwise both fields are required so an author cannot silently produce a non-JSON-safe contract artifact.
+ */
+type JsonRoundTripConfig<TInput> = [TInput] extends [JsonValue] ? {
+  encodeJson?: (value: TInput) => JsonValue;
+  decodeJson?: (json: JsonValue) => TInput;
+} : {
+  encodeJson: (value: TInput) => JsonValue;
+  decodeJson: (json: JsonValue) => TInput;
+};
+/**
+ * Construct a Mongo codec from author functions.
+ *
+ * Author `encode` and `decode` as sync or async functions; the factory produces a {@link MongoCodec} whose query-time methods follow the boundary contract documented on the framework {@link BaseCodec}. Authors receive a second `ctx` options argument carrying the per-call context; ignore it if you don't need it.
+ *
+ * Both `encode` and `decode` are required so `TInput` and `TWire` are always covered by an explicit author function — the factory installs no identity fallback. `encodeJson` and `decodeJson` default to identity **only when `TInput` is assignable to `JsonValue`**; otherwise both are required so the contract artifact stays JSON-safe.
+ *
+ * Codec-id-keyed static metadata (`traits`, `targetTypes`, `renderOutputType`) lives on the unified `CodecDescriptor` rather than on the codec instance itself (TML-2357).
+ */
+declare function mongoCodec<Id extends string, const TTraits extends readonly MongoCodecTrait[] = readonly [], TWire = unknown, TInput = unknown>(config: {
+  typeId: Id;
+  encode: (value: TInput, ctx: CodecCallContext) => TWire | Promise<TWire>;
+  decode: (wire: TWire, ctx: CodecCallContext) => TInput | Promise<TInput>;
+} & JsonRoundTripConfig<TInput>): MongoCodec<Id, TTraits, TWire, TInput>;
+/** Extract the JS application type carried by a Mongo codec — used both as `encode` input and as `decode` output. */
+type MongoCodecInput<T> = T extends MongoCodec<string, readonly MongoCodecTrait[], unknown, infer TInput> ? TInput : never;
+//#endregion
+//#region src/codec-registry.d.ts
+interface MongoCodecRegistry {
+  get(id: string): MongoCodec<string> | undefined;
+  has(id: string): boolean;
+  register(codec: MongoCodec<string>): void;
+  [Symbol.iterator](): Iterator<MongoCodec<string>>;
+  values(): IterableIterator<MongoCodec<string>>;
+}
+/**
+ * Create a new Mongo codec registry. Inline object literal — no class implementation; the registry is just a private `Map` with the documented surface methods.
+ */
+declare function newMongoCodecRegistry(): MongoCodecRegistry;
+//#endregion
+export { mongoCodec as a, MongoCodecTrait as i, MongoCodecInput as n, newMongoCodecRegistry as o, MongoCodecRegistry as r, MongoCodec as t };
+//# sourceMappingURL=index-Dv2PNMiG.d.mts.map

package/dist/index-Dv2PNMiG.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Dv2PNMiG.d.mts","names":[],"sources":["../../../../2-mongo-family/1-foundation/mongo-codec/dist/index.d.mts"],"mappings":";;;;KAGK,kBAAkB;;;;;;UAMb,WAAW,4BAA4B,yBAAyB,6BAA6B,mBAAmB,iBAAiB,0BAA0B,MAAM,IAAI,SAAS,OAAO;;;;KAI1L,oBAAoB,WAAW,iBAAiB;EACnD,cAAc,OAAO,WAAW;EAChC,cAAc,MAAM,cAAc;;EAElC,aAAa,OAAO,WAAW;EAC/B,aAAa,MAAM,cAAc;;;;;;;;;;;iBAWlB,WAAW,yBAAyB,yBAAyB,iCAAiC,iBAAiB,kBAAkB;EAChJ,QAAQ;EACR,SAAS,OAAO,QAAQ,KAAK,qBAAqB,QAAQ,QAAQ;EAClE,SAAS,MAAM,OAAO,KAAK,qBAAqB,SAAS,QAAQ;IAC/D,oBAAoB,UAAU,WAAW,IAAI,SAAS,OAAO;;KAE5D,gBAAgB,KAAK,UAAU,4BAA4B,kCAAkC,UAAU;;;UAGlG;EACR,IAAI,aAAa;EACjB,IAAI;EACJ,SAAS,OAAO;GACf,OAAO,aAAa,SAAS;EAC9B,UAAU,iBAAiB;;;;;iBAKZ,yBAAyB"}

package/dist/index-DxoO-ywI.d.mts

@@ -0,0 +1,178 @@
+import { t as CollationOptions } from "./mongodb-types-B4HmhF1S.mjs";
+import { A as MongoIndexKey } from "./mongo-value-set-tNn9-pun-dJYx_rVD.mjs";
+import "./index-Cd2zLiU6.mjs";
+import { IRNodeBase } from "@prisma/orm-framework/components/ir";
+import { DiffableNode } from "@prisma/orm-framework/components/control";
+//#region ../../../2-mongo-family/3-tooling/mongo-schema-ir/dist/exports/index.d.mts
+//#region src/canonicalize.d.ts
+declare function canonicalize(obj: unknown): string;
+//#endregion
+//#region src/schema-collection-options.d.ts
+interface MongoSchemaCollectionOptionsInput {
+  readonly capped?: {
+    size: number;
+    max?: number;
+  };
+  readonly timeseries?: {
+    timeField: string;
+    metaField?: string;
+    granularity?: 'seconds' | 'minutes' | 'hours';
+  };
+  readonly collation?: CollationOptions;
+  readonly changeStreamPreAndPostImages?: {
+    enabled: boolean;
+  };
+  readonly clusteredIndex?: {
+    name?: string;
+  };
+}
+declare class MongoSchemaCollectionOptions extends MongoSchemaIRNode {
+  readonly nodeKind: "collectionOptions";
+  /** Fixed sentinel: at most one options node exists per collection. */
+  readonly id = "options";
+  readonly capped?: {
+    size: number;
+    max?: number;
+  } | undefined;
+  readonly timeseries?: {
+    timeField: string;
+    metaField?: string;
+    granularity?: 'seconds' | 'minutes' | 'hours';
+  } | undefined;
+  readonly collation?: CollationOptions | undefined;
+  readonly changeStreamPreAndPostImages?: {
+    enabled: boolean;
+  } | undefined;
+  readonly clusteredIndex?: {
+    name?: string;
+  } | undefined;
+  constructor(options: MongoSchemaCollectionOptionsInput);
+  accept<R>(visitor: MongoSchemaVisitor<R>): R;
+}
+//#endregion
+//#region src/schema-validator.d.ts
+interface MongoSchemaValidatorOptions {
+  readonly jsonSchema: Record<string, unknown>;
+  readonly validationLevel: 'strict' | 'moderate';
+  readonly validationAction: 'error' | 'warn';
+}
+declare class MongoSchemaValidator extends MongoSchemaIRNode {
+  readonly nodeKind: "validator";
+  /** Fixed sentinel: at most one validator exists per collection. */
+  readonly id = "validator";
+  readonly jsonSchema: Record<string, unknown>;
+  readonly validationLevel: 'strict' | 'moderate';
+  readonly validationAction: 'error' | 'warn';
+  constructor(options: MongoSchemaValidatorOptions);
+  accept<R>(visitor: MongoSchemaVisitor<R>): R;
+}
+//#endregion
+//#region src/schema-collection.d.ts
+interface MongoSchemaCollectionCtorOptions {
+  readonly name: string;
+  readonly indexes?: ReadonlyArray<MongoSchemaIndex>;
+  readonly validator?: MongoSchemaValidator;
+  readonly options?: MongoSchemaCollectionOptions;
+}
+declare class MongoSchemaCollection extends MongoSchemaIRNode {
+  readonly nodeKind: "collection";
+  readonly id: string;
+  readonly name: string;
+  readonly indexes: ReadonlyArray<MongoSchemaIndex>;
+  readonly validator?: MongoSchemaValidator | undefined;
+  readonly options?: MongoSchemaCollectionOptions | undefined;
+  constructor(options: MongoSchemaCollectionCtorOptions);
+  accept<R>(visitor: MongoSchemaVisitor<R>): R;
+}
+//#endregion
+//#region src/schema-ir.d.ts
+declare class MongoSchemaIR extends MongoSchemaIRNode {
+  readonly nodeKind: "schema";
+  /** Fixed sentinel: the schema is always the diff tree's single root. */
+  readonly id = "schema";
+  readonly collections: ReadonlyArray<MongoSchemaCollection>;
+  readonly collectionNames: ReadonlyArray<string>;
+  private readonly _byName;
+  constructor(collections: ReadonlyArray<MongoSchemaCollection>);
+  accept<R>(visitor: MongoSchemaVisitor<R>): R;
+  collection(name: string): MongoSchemaCollection | undefined;
+}
+//#endregion
+//#region src/visitor.d.ts
+interface MongoSchemaVisitor<R> {
+  schema(node: MongoSchemaIR): R;
+  collection(node: MongoSchemaCollection): R;
+  index(node: MongoSchemaIndex): R;
+  validator(node: MongoSchemaValidator): R;
+  collectionOptions(node: MongoSchemaCollectionOptions): R;
+}
+//#endregion
+//#region src/schema-node.d.ts
+/**
+ * Every concrete Mongo schema-IR node also implements the framework's
+ * `DiffableNode` interface, so a node can be carried as the `expected`/
+ * `actual` payload of a `SchemaDiffIssue`. Mongo's own diff (`diffMongoSchemas`)
+ * still hand-rolls its comparisons and never calls `isEqualTo`/`children` —
+ * this conformance exists so an issue can carry the real collection/index/
+ * validator/options node it concerns, not a coordinate string.
+ *
+ * Follow-up: `isEqualTo`/`children` are dead weight on every Mongo node
+ * (nothing calls them). The honest fix is splitting `DiffableNode` into a
+ * narrower "issue payload" bound (just `id`) that this class implements,
+ * separate from the full walkable `DiffableNode` (`id` + `isEqualTo` +
+ * `children`) the generic differ actually pairs and recurses over.
+ */
+declare abstract class MongoSchemaIRNode extends IRNodeBase implements DiffableNode {
+  readonly kind: string;
+  abstract readonly id: string;
+  /** Per-node discriminant `DiffableNode` requires: collection / index / validator / collectionOptions / schema. */
+  abstract readonly nodeKind: string;
+  abstract accept<R>(visitor: MongoSchemaVisitor<R>): R;
+  constructor();
+  isEqualTo(other: DiffableNode): boolean;
+  children(): readonly DiffableNode[];
+}
+//#endregion
+//#region src/schema-index.d.ts
+interface MongoSchemaIndexOptions {
+  readonly keys: ReadonlyArray<MongoIndexKey>;
+  readonly unique?: boolean | undefined;
+  readonly sparse?: boolean | undefined;
+  readonly expireAfterSeconds?: number | undefined;
+  readonly partialFilterExpression?: Record<string, unknown> | undefined;
+  readonly wildcardProjection?: Record<string, 0 | 1> | undefined;
+  readonly collation?: CollationOptions | undefined;
+  readonly weights?: Record<string, number> | undefined;
+  readonly default_language?: string | undefined;
+  readonly language_override?: string | undefined;
+}
+declare class MongoSchemaIndex extends MongoSchemaIRNode {
+  readonly nodeKind: "index";
+  readonly id: string;
+  readonly keys: ReadonlyArray<MongoIndexKey>;
+  readonly unique: boolean;
+  readonly sparse?: boolean | undefined;
+  readonly expireAfterSeconds?: number | undefined;
+  readonly partialFilterExpression?: Record<string, unknown> | undefined;
+  readonly wildcardProjection?: Record<string, 0 | 1> | undefined;
+  readonly collation?: CollationOptions | undefined;
+  readonly weights?: Record<string, number> | undefined;
+  readonly default_language?: string | undefined;
+  readonly language_override?: string | undefined;
+  constructor(options: MongoSchemaIndexOptions);
+  accept<R>(visitor: MongoSchemaVisitor<R>): R;
+}
+//#endregion
+//#region src/index-equivalence.d.ts
+/**
+ * Key-order-sensitive structural comparison. For key-order-independent
+ * comparison (e.g. lookup key construction), use {@link canonicalize}.
+ */
+declare function deepEqual(a: unknown, b: unknown): boolean;
+declare function indexesEquivalent(a: MongoSchemaIndex, b: MongoSchemaIndex): boolean;
+//#endregion
+//#region src/types.d.ts
+type AnyMongoSchemaNode = MongoSchemaIR | MongoSchemaCollection | MongoSchemaCollectionOptions | MongoSchemaIndex | MongoSchemaValidator;
+//#endregion
+export { MongoSchemaCollectionOptionsInput as a, MongoSchemaIndex as c, MongoSchemaValidatorOptions as d, MongoSchemaVisitor as f, indexesEquivalent as h, MongoSchemaCollectionOptions as i, MongoSchemaIndexOptions as l, deepEqual as m, MongoSchemaCollection as n, MongoSchemaIR as o, canonicalize as p, MongoSchemaCollectionCtorOptions as r, MongoSchemaIRNode as s, AnyMongoSchemaNode as t, MongoSchemaValidator as u };
+//# sourceMappingURL=index-DxoO-ywI.d.mts.map

package/dist/index-DxoO-ywI.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DxoO-ywI.d.mts","names":[],"sources":["../../../../2-mongo-family/3-tooling/mongo-schema-ir/dist/exports/index.d.mts"],"mappings":";;;;;;;iBAKiB,aAAa;;;UAGpB;WACC;IACP;IACA;;WAEO;IACP;IACA;IACA;;WAEO,YAAY;WACZ;IACP;;WAEO;IACP;;;cAGU,qCAAqC;WACxC;;WAEA;WACA;IACP;IACA;;WAEO;IACP;IACA;IACA;;WAEO,YAAY;WACZ;IACP;;WAEO;IACP;;EAEF,YAAY,SAAS;EACrB,OAAO,GAAG,SAAS,mBAAmB,KAAK;;;;UAInC;WACC,YAAY;WACZ;WACA;;cAEG,6BAA6B;WAChC;;WAEA;WACA,YAAY;WACZ;WACA;EACT,YAAY,SAAS;EACrB,OAAO,GAAG,SAAS,mBAAmB,KAAK;;;;UAInC;WACC;WACA,UAAU,cAAc;WACxB,YAAY;WACZ,UAAU;;cAEP,8BAA8B;WACjC;WACA;WACA;WACA,SAAS,cAAc;WACvB,YAAY;WACZ,UAAU;EACnB,YAAY,SAAS;EACrB,OAAO,GAAG,SAAS,mBAAmB,KAAK;;;;cAI/B,sBAAsB;WACzB;;WAEA;WACA,aAAa,cAAc;WAC3B,iBAAiB;mBACT;EACjB,YAAY,aAAa,cAAc;EACvC,OAAO,GAAG,SAAS,mBAAmB,KAAK;EAC3C,WAAW,eAAe;;;;UAIlB,mBAAmB;EAC3B,OAAO,MAAM,gBAAgB;EAC7B,WAAW,MAAM,wBAAwB;EACzC,MAAM,MAAM,mBAAmB;EAC/B,UAAU,MAAM,uBAAuB;EACvC,kBAAkB,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;uBAkBlC,0BAA0B,sBAAsB;WAC5D;oBACS;;oBAEA;WACT,OAAO,GAAG,SAAS,mBAAmB,KAAK;EACpD;EACA,UAAU,OAAO;EACjB,qBAAqB;;;;UAIb;WACC,MAAM,cAAc;WACpB;WACA;WACA;WACA,0BAA0B;WAC1B,qBAAqB;WACrB,YAAY;WACZ,UAAU;WACV;WACA;;cAEG,yBAAyB;WAC5B;WACA;WACA,MAAM,cAAc;WACpB;WACA;WACA;WACA,0BAA0B;WAC1B,qBAAqB;WACrB,YAAY;WACZ,UAAU;WACV;WACA;EACT,YAAY,SAAS;EACrB,OAAO,GAAG,SAAS,mBAAmB,KAAK;;;;;;;;iBAQ5B,UAAU,YAAY;iBACtB,kBAAkB,GAAG,kBAAkB,GAAG;;;KAGtD,qBAAqB,gBAAgB,wBAAwB,+BAA+B,mBAAmB"}

package/dist/index-wKMm41HC.d.mts

@@ -0,0 +1,30 @@
+//#region ../../../2-mongo-family/1-foundation/mongo-value/dist/index.d.mts
+//#region src/param-ref.d.ts
+declare class MongoParamRef {
+  readonly value: unknown;
+  readonly name: string | undefined;
+  readonly codecId: string | undefined;
+  constructor(value: unknown, options?: {
+    name?: string;
+    codecId?: string;
+  });
+  static of(value: unknown, options?: {
+    name?: string;
+    codecId?: string;
+  }): MongoParamRef;
+}
+//#endregion
+//#region src/values.d.ts
+type LiteralValue = string | number | boolean | null | Date;
+type MongoValue = MongoParamRef | LiteralValue | MongoDocument | MongoArray;
+interface MongoDocument {
+  readonly [key: string]: MongoValue;
+}
+interface MongoArray extends ReadonlyArray<MongoValue> {}
+type MongoExpr = MongoDocument;
+type MongoUpdateDocument = Record<string, MongoValue>;
+type RawPipeline = ReadonlyArray<Record<string, unknown>>;
+type Document = Record<string, unknown>;
+//#endregion
+export { MongoExpr as a, MongoValue as c, MongoDocument as i, RawPipeline as l, LiteralValue as n, MongoParamRef as o, MongoArray as r, MongoUpdateDocument as s, Document as t };
+//# sourceMappingURL=index-wKMm41HC.d.mts.map

package/dist/index-wKMm41HC.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-wKMm41HC.d.mts","names":[],"sources":["../../../../2-mongo-family/1-foundation/mongo-value/dist/index.d.mts"],"mappings":";;cACc;WACH;WACA;WACA;EACT,YAAY,gBAAgB;IAC1B;IACA;;SAEK,GAAG,gBAAgB;IACxB;IACA;MACE;;;;KAID,kDAAkD;KAClD,aAAa,gBAAgB,eAAe,gBAAgB;UACvD;YACE,cAAc;;UAEhB,mBAAmB,cAAc;KACtC,YAAY;KACZ,sBAAsB,eAAe;KACrC,cAAc,cAAc;KAC5B,WAAW"}