@danceroutine/tango-orm 1.11.0 → 1.11.2

package/dist/registerModelObjects-C-MliIiM.d.ts

@@ -0,0 +1,229 @@
+import { t as DBClient } from "./DBClient-DuYcXolQ.js";
+import { i as Dialect, t as Adapter } from "./Adapter-DKxAaL4l.js";
+import { E as ManyToManyRelatedManager, F as QNode, H as TableMeta, I as FilterInput, N as QuerySet } from "./QuerySetState-CjyvAUBs.js";
+import { ModelWriteHooks } from "@danceroutine/tango-schema";
+import { LoadedConfig } from "@danceroutine/tango-config";
+import { z } from "zod";
+import { Model, PersistedModelOutput } from "@danceroutine/tango-schema/domain";
+import { DecoratedFieldKind, InternalDecoratedFieldKind, RelationDecoratedSchema } from "@danceroutine/tango-schema/model";
+
+//#region src/manager/relations/MaterializedModelRecord.d.ts
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+type AnyModel = Model<z.ZodObject<z.ZodRawShape>, string>;
+type SchemaShape<TSchema> = TSchema extends z.ZodObject<infer TShape> ? TShape : never;
+type RelationKindOf<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, infer TKind extends DecoratedFieldKind, AnyModel, string | undefined, string | undefined> ? TKind : never;
+type RelationTarget<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, DecoratedFieldKind, infer TTarget, string | undefined, string | undefined> ? TTarget : never;
+type RelationPublishedName<TField, TFallback extends string> = TField extends RelationDecoratedSchema<z.ZodTypeAny, DecoratedFieldKind, AnyModel, infer TName extends string | undefined, string | undefined> ? TName extends string ? TName : TFallback : TFallback;
+type ModelRow<TTarget> = TTarget extends Model<infer TSchema extends z.ZodObject<z.ZodRawShape>, string> ? PersistedModelOutput<TSchema> : never;
+type ManyToManyKeysOfShape<TShape extends z.ZodRawShape> = Extract<{ [K in keyof TShape]: IsAny<TShape[K]> extends true ? never : [RelationKindOf<TShape[K]>] extends [never] ? never : [RelationKindOf<TShape[K]>] extends [typeof InternalDecoratedFieldKind.MANY_TO_MANY] ? K : never }[keyof TShape], string>;
+type ManyToManyManagers<TShape extends z.ZodRawShape> = { readonly [K in ManyToManyKeysOfShape<TShape> as K extends keyof TShape ? RelationPublishedName<TShape[K], K> : never]: K extends keyof TShape ? RelationTarget<TShape[K]> extends AnyModel ? ManyToManyRelatedManager<ModelRow<RelationTarget<TShape[K]>>> : never : never };
+/**
+ * Persisted model record shape returned by ORM read and write paths.
+ *
+ * Combines the column-level {@link PersistedModelOutput} with a per-relation
+ * {@link ManyToManyRelatedManager} for every many-to-many field declared on the
+ * source schema. The manager properties are attached as non-enumerable accessors
+ * at runtime, so `JSON.stringify` and structural equality checks only see the
+ * column data.
+ */
+type MaterializedModelRecord<TSchema extends z.ZodObject<z.ZodRawShape>> = PersistedModelOutput<TSchema> & ManyToManyManagers<SchemaShape<TSchema>>;
+//#endregion
+//#region src/manager/ManagerLike.d.ts
+/**
+ * Public manager contract consumed by Tango resources and applications.
+ */
+interface ManagerLike<TModelRow extends Record<string, unknown>, TSourceModel = unknown> {
+  readonly meta: TableMeta;
+  query(): QuerySet<TModelRow, TModelRow, TSourceModel>;
+  all(): QuerySet<TModelRow, TModelRow, TSourceModel>;
+  getOrCreate(args: {
+    where: FilterInput<TModelRow> | QNode<TModelRow>;
+    defaults?: Partial<TModelRow>;
+  }): Promise<{
+    record: TModelRow;
+    created: boolean;
+  }>;
+  updateOrCreate(args: {
+    where: FilterInput<TModelRow> | QNode<TModelRow>;
+    defaults?: Partial<TModelRow>;
+    update?: Partial<TModelRow>;
+  }): Promise<{
+    record: TModelRow;
+    created: boolean;
+    updated: boolean;
+  }>;
+  findById(id: TModelRow[keyof TModelRow]): Promise<TModelRow | null>;
+  getOrThrow(id: TModelRow[keyof TModelRow]): Promise<TModelRow>;
+  create(input: Partial<TModelRow>): Promise<TModelRow>;
+  update(id: TModelRow[keyof TModelRow], patch: Partial<TModelRow>): Promise<TModelRow>;
+  delete(id: TModelRow[keyof TModelRow]): Promise<void>;
+  bulkCreate(inputs: Partial<TModelRow>[]): Promise<TModelRow[]>;
+}
+//#endregion
+//#region src/runtime/internal/DBClientProvider.d.ts
+interface TransactionClientLease {
+  readonly client: DBClient;
+  release(): Promise<void>;
+}
+//#endregion
+//#region src/runtime/TangoRuntime.d.ts
+/**
+ * Framework-owned database runtime that resolves Tango config and lazily
+ * creates the shared connection provider used by manager-backed models.
+ */
+declare class TangoRuntime {
+  static readonly BRAND: "tango.orm.runtime";
+  readonly __tangoBrand: typeof TangoRuntime.BRAND;
+  private readonly loadedConfig;
+  private providerPromise;
+  private runtimeClientPromise;
+  private cachedAdapter;
+  constructor(loadLoadedConfig: () => LoadedConfig);
+  /**
+   * Narrow an unknown value to `TangoRuntime`.
+   */
+  static isTangoRuntime(value: unknown): value is TangoRuntime;
+  /**
+   * Return the loaded Tango config snapshot for the active environment.
+   */
+  getConfig(): LoadedConfig;
+  /**
+   * Return the configured SQL dialect for the current runtime.
+   */
+  getDialect(): Dialect;
+  /**
+   * Return the adapter backing the configured dialect. Manager-side
+   * compilers use this to obtain placeholder formatters and dialect
+   * capabilities without branching on the raw dialect string.
+   */
+  getAdapter(): Adapter;
+  /**
+   * Return the runtime-bound DB client facade used by manager-backed code.
+   */
+  getClient(): Promise<DBClient>;
+  /**
+   * Execute SQL through the autocommit path owned by this runtime.
+   */
+  query<T = unknown>(sql: string, params?: readonly unknown[]): Promise<{
+    rows: T[];
+  }>;
+  /**
+   * Lease a transaction-scoped client for `transaction.atomic(...)`.
+   */
+  leaseTransactionClient(): Promise<TransactionClientLease>;
+  /**
+   * Close and clear the cached runtime resources so tests can start fresh.
+   */
+  reset(): Promise<void>;
+  private buildAdapterForDialect;
+  private getProvider;
+}
+//#endregion
+//#region src/manager/ModelManager.d.ts
+type ModelMetadataLike = Omit<Model['metadata'], 'key' | 'namespace' | 'fields'> & {
+  key?: string;
+  namespace?: string;
+  fields: Array<{
+    name: string;
+    type: string;
+    primaryKey?: boolean;
+  }>;
+};
+type ModelLike<TModelRow extends Record<string, unknown>> = {
+  metadata: ModelMetadataLike;
+  schema: {
+    parse(input: unknown): TModelRow;
+  };
+  hooks?: ModelWriteHooks<TModelRow>;
+};
+/**
+ * Model-backed data access API exposed as `Model.objects`.
+ */
+declare class ModelManager<TModelRow extends Record<string, unknown>, TSourceModel = unknown> implements ManagerLike<TModelRow, TSourceModel> {
+  static readonly BRAND: "tango.orm.model_manager";
+  readonly __tangoBrand: typeof ModelManager.BRAND;
+  private readonly queryExecutor;
+  private readonly mutationCompiler;
+  private readonly model;
+  private readonly client;
+  private readonly adapter;
+  private readonly runtime;
+  constructor(model: ModelLike<TModelRow>, runtime: TangoRuntime);
+  get meta(): TableMeta;
+  /**
+   * Narrow an unknown value to `ModelManager`.
+   */
+  static isModelManager<TModelRow extends Record<string, unknown>>(value: unknown): value is ModelManager<TModelRow>;
+  private static createTableMeta;
+  private static mergeCreatePayloadFromWhere;
+  private static countDefinedValues;
+  private static collectPlainFieldsFromQNode;
+  private static omitLookupKeysFromAtom;
+  private static mergeCompatiblePartials;
+  query(): QuerySet<TModelRow, TModelRow, TSourceModel>;
+  all(): QuerySet<TModelRow, TModelRow, TSourceModel>;
+  findById(id: TModelRow[keyof TModelRow]): Promise<TModelRow | null>;
+  getOrThrow(id: TModelRow[keyof TModelRow]): Promise<TModelRow>;
+  getOrCreate(args: {
+    where: FilterInput<TModelRow> | QNode<TModelRow>;
+    defaults?: Partial<TModelRow>;
+  }): Promise<{
+    record: TModelRow;
+    created: boolean;
+  }>;
+  updateOrCreate(args: {
+    where: FilterInput<TModelRow> | QNode<TModelRow>;
+    defaults?: Partial<TModelRow>;
+    update?: Partial<TModelRow>;
+  }): Promise<{
+    record: TModelRow;
+    created: boolean;
+    updated: boolean;
+  }>;
+  create(input: Partial<TModelRow>): Promise<TModelRow>;
+  update(id: TModelRow[keyof TModelRow], patch: Partial<TModelRow>): Promise<TModelRow>;
+  delete(id: TModelRow[keyof TModelRow]): Promise<void>;
+  /**
+   * Build a {@link ManyToManyRelatedManager} bound to a single owner record
+   * for the supplied many-to-many relation. The returned manager performs
+   * its INSERT/DELETE writes through the shared runtime-bound client, so
+   * mutations enroll in any active `transaction.atomic(...)` boundary.
+   */
+  createManyToManyRelatedManager<TTarget extends Record<string, unknown>>(relationName: string, ownerPrimaryKey: unknown): ManyToManyRelatedManager<TTarget>;
+  /**
+   * Insert multiple rows in a single multi-row INSERT statement.
+   *
+   * All rows must share the same field set after hook processing. Rows with
+   * extra or missing fields relative to the first row will cause an error.
+   * If you need to insert rows with different field sets, use individual
+   * {@link create} calls instead.
+   */
+  bulkCreate(inputs: Partial<TModelRow>[]): Promise<TModelRow[]>;
+  /**
+   * Attach a {@link ManyToManyRelatedManager} as a non-enumerable property
+   * for every persisted many-to-many relation declared on the supplied
+   * record's model. Existing properties are left untouched so that prior
+   * hydration writes (such as prefetched arrays) survive the attach pass
+   * during the incremental rollout of related-manager hydration.
+   */
+  private attachOwnRelatedManagers;
+  private attachManyToManyRelatedManagers;
+  private resolveManagerForModelKey;
+  private resolveTargetExecutor;
+  private resolveTargetManager;
+  private requireManyToManyEdge;
+  private runBeforeCreate;
+  private runBeforeUpdate;
+  private getHookTransaction;
+  private assertUniformRowShape;
+}
+//#endregion
+//#region src/manager/registerModelObjects.d.ts
+/**
+ * Install the schema model augmentor that exposes `Model.objects`.
+ * This registration is idempotent so multiple Tango entrypoints can safely call it.
+ */
+declare function registerModelObjects(): void;
+//#endregion
+export { MaterializedModelRecord as a, ManagerLike as i, ModelManager as n, TangoRuntime as r, registerModelObjects as t };
+//# sourceMappingURL=registerModelObjects-C-MliIiM.d.ts.map