@danceroutine/tango-schema 1.11.0 → 1.11.2

package/dist/chunk-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/domain/index.d.ts

@@ -1,13 +1,2 @@
-/**
- * Domain boundary barrel: centralizes this subdomain's public contract.
- */
-export type { FieldType } from './FieldType';
-export type { DeleteReferentialAction } from './DeleteReferentialAction';
-export type { UpdateReferentialAction } from './UpdateReferentialAction';
-export type { RelationType } from './RelationType';
-export type { Field } from './Field';
-export type { IndexDef } from './IndexDef';
-export type { RelationDef } from './RelationDef';
-export type { ModelMetadata } from './ModelMetadata';
-export type { Model, ModelAugmentations, ModelKeyOf, PersistedModelOutput } from './Model';
-export type { ModelHookModel, ModelWriteHookOnCommitOptions, ModelWriteHookManager, ModelWriteHookTransaction, ModelWriteHooks, BeforeCreateHookArgs, AfterCreateHookArgs, BeforeUpdateHookArgs, AfterUpdateHookArgs, BeforeDeleteHookArgs, AfterDeleteHookArgs, BeforeBulkCreateHookArgs, AfterBulkCreateHookArgs, } from './ModelWriteHooks';
+import { A as FieldType, C as ModelMetadata, D as RelationType, E as Field, O as UpdateReferentialAction, S as ModelWriteHooks, T as IndexDef, _ as BeforeUpdateHookArgs, a as PersistedModelOutput, b as ModelWriteHookOnCommitOptions, d as AfterCreateHookArgs, f as AfterDeleteHookArgs, g as BeforeDeleteHookArgs, h as BeforeCreateHookArgs, i as ModelKeyOf, k as DeleteReferentialAction, m as BeforeBulkCreateHookArgs, n as Model, p as AfterUpdateHookArgs, r as ModelAugmentations, u as AfterBulkCreateHookArgs, v as ModelHookModel, w as RelationDef, x as ModelWriteHookTransaction, y as ModelWriteHookManager } from "../index-Bhh0b304.js";
+export type { AfterBulkCreateHookArgs, AfterCreateHookArgs, AfterDeleteHookArgs, AfterUpdateHookArgs, BeforeBulkCreateHookArgs, BeforeCreateHookArgs, BeforeDeleteHookArgs, BeforeUpdateHookArgs, DeleteReferentialAction, Field, FieldType, IndexDef, Model, ModelAugmentations, ModelHookModel, ModelKeyOf, ModelMetadata, ModelWriteHookManager, ModelWriteHookOnCommitOptions, ModelWriteHookTransaction, ModelWriteHooks, PersistedModelOutput, RelationDef, RelationType, UpdateReferentialAction };

package/dist/domain/index.js

@@ -1 +1,7 @@
-import "../domain-Cufz6y1q.js";
+import { t as __exportAll } from "../chunk-D7D4PA-g.js";
+//#region src/domain/index.ts
+var domain_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+export { domain_exports as t };
+
+//# sourceMappingURL=index.js.map

package/dist/domain/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/domain/index.ts"],"sourcesContent":["/**\n * Domain boundary barrel: centralizes this subdomain's public contract.\n */\n\nexport type { FieldType } from './FieldType';\nexport type { DeleteReferentialAction } from './DeleteReferentialAction';\nexport type { UpdateReferentialAction } from './UpdateReferentialAction';\nexport type { RelationType } from './RelationType';\nexport type { Field } from './Field';\nexport type { IndexDef } from './IndexDef';\nexport type { RelationDef } from './RelationDef';\nexport type { ModelMetadata } from './ModelMetadata';\nexport type { Model, ModelAugmentations, ModelKeyOf, PersistedModelOutput } from './Model';\nexport type {\n    ModelHookModel,\n    ModelWriteHookOnCommitOptions,\n    ModelWriteHookManager,\n    ModelWriteHookTransaction,\n    ModelWriteHooks,\n    BeforeCreateHookArgs,\n    AfterCreateHookArgs,\n    BeforeUpdateHookArgs,\n    AfterUpdateHookArgs,\n    BeforeDeleteHookArgs,\n    AfterDeleteHookArgs,\n    BeforeBulkCreateHookArgs,\n    AfterBulkCreateHookArgs,\n} from './ModelWriteHooks';\n"],"mappings":""}

package/dist/index-Bhh0b304.d.ts

@@ -0,0 +1,246 @@
+import { z } from "zod";
+
+//#region src/domain/internal/InternalFieldType.d.ts
+declare const InternalFieldType: {
+  readonly SERIAL: "serial";
+  readonly INT: "int";
+  readonly BIGINT: "bigint";
+  readonly TEXT: "text";
+  readonly BOOL: "bool";
+  readonly TIMESTAMPTZ: "timestamptz";
+  readonly JSONB: "jsonb";
+  readonly UUID: "uuid";
+};
+//#endregion
+//#region src/domain/FieldType.d.ts
+type FieldType = (typeof InternalFieldType)[keyof typeof InternalFieldType];
+//#endregion
+//#region src/domain/DeleteReferentialAction.d.ts
+type DeleteReferentialAction = 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+//#endregion
+//#region src/domain/UpdateReferentialAction.d.ts
+type UpdateReferentialAction = 'CASCADE' | 'RESTRICT' | 'NO ACTION';
+//#endregion
+//#region src/domain/internal/InternalRelationType.d.ts
+declare const InternalRelationType: {
+  readonly HAS_MANY: "hasMany";
+  readonly BELONGS_TO: "belongsTo";
+  readonly HAS_ONE: "hasOne";
+};
+//#endregion
+//#region src/domain/RelationType.d.ts
+type RelationType = (typeof InternalRelationType)[keyof typeof InternalRelationType];
+//#endregion
+//#region src/domain/Field.d.ts
+interface Field {
+  name: string;
+  type: FieldType;
+  notNull?: boolean;
+  default?: string | {
+    now: true;
+  } | null;
+  primaryKey?: boolean;
+  unique?: boolean;
+  references?: {
+    table: string;
+    column: string;
+    onDelete?: DeleteReferentialAction;
+    onUpdate?: UpdateReferentialAction;
+  };
+  renameFrom?: string;
+}
+//#endregion
+//#region src/domain/IndexDef.d.ts
+interface IndexDef {
+  name: string;
+  on: string[];
+  unique?: boolean;
+  where?: string;
+}
+//#endregion
+//#region src/domain/RelationDef.d.ts
+interface RelationDef {
+  type: RelationType;
+  target: string;
+  foreignKey: string;
+  localKey?: string;
+}
+//#endregion
+//#region src/domain/ModelMetadata.d.ts
+interface ModelMetadata {
+  namespace: string;
+  name: string;
+  key: string;
+  table: string;
+  fields: Field[];
+  indexes?: IndexDef[];
+  relations?: Record<string, RelationDef>;
+  ordering?: string[];
+  managed?: boolean;
+  defaultRelatedName?: string;
+  constraints?: unknown[];
+}
+//#endregion
+//#region src/domain/ModelWriteHooks.d.ts
+interface ModelWriteHookManager<TModel extends Record<string, unknown>> {
+  create(input: Partial<TModel>): Promise<TModel>;
+  update(id: TModel[keyof TModel], patch: Partial<TModel>): Promise<TModel>;
+  delete(id: TModel[keyof TModel]): Promise<void>;
+  bulkCreate(inputs: Partial<TModel>[]): Promise<TModel[]>;
+}
+interface ModelWriteHookOnCommitOptions {
+  robust?: boolean;
+}
+interface ModelWriteHookTransaction {
+  onCommit(callback: () => void, options?: ModelWriteHookOnCommitOptions): void;
+}
+/**
+ * Structural model contract passed into write lifecycle hooks.
+ */
+interface ModelHookModel<TModel extends Record<string, unknown>> {
+  metadata: {
+    table: string;
+  };
+  schema: {
+    parse(input: unknown): TModel;
+  };
+  hooks?: ModelWriteHooks<TModel>;
+}
+interface BeforeCreateHookArgs<TModel extends Record<string, unknown>> {
+  data: Partial<TModel>;
+  model: ModelHookModel<TModel>;
+  manager: ModelWriteHookManager<TModel>;
+  transaction?: ModelWriteHookTransaction;
+}
+interface AfterCreateHookArgs<TModel extends Record<string, unknown>> {
+  record: TModel;
+  model: ModelHookModel<TModel>;
+  manager: ModelWriteHookManager<TModel>;
+  transaction?: ModelWriteHookTransaction;
+}
+interface BeforeUpdateHookArgs<TModel extends Record<string, unknown>> {
+  id: TModel[keyof TModel];
+  patch: Partial<TModel>;
+  current: TModel;
+  model: ModelHookModel<TModel>;
+  manager: ModelWriteHookManager<TModel>;
+  transaction?: ModelWriteHookTransaction;
+}
+interface AfterUpdateHookArgs<TModel extends Record<string, unknown>> {
+  id: TModel[keyof TModel];
+  patch: Partial<TModel>;
+  previous: TModel;
+  record: TModel;
+  model: ModelHookModel<TModel>;
+  manager: ModelWriteHookManager<TModel>;
+  transaction?: ModelWriteHookTransaction;
+}
+interface BeforeDeleteHookArgs<TModel extends Record<string, unknown>> {
+  id: TModel[keyof TModel];
+  current: TModel;
+  model: ModelHookModel<TModel>;
+  manager: ModelWriteHookManager<TModel>;
+  transaction?: ModelWriteHookTransaction;
+}
+interface AfterDeleteHookArgs<TModel extends Record<string, unknown>> {
+  id: TModel[keyof TModel];
+  previous: TModel;
+  model: ModelHookModel<TModel>;
+  manager: ModelWriteHookManager<TModel>;
+  transaction?: ModelWriteHookTransaction;
+}
+interface BeforeBulkCreateHookArgs<TModel extends Record<string, unknown>> {
+  rows: Partial<TModel>[];
+  model: ModelHookModel<TModel>;
+  manager: ModelWriteHookManager<TModel>;
+  transaction?: ModelWriteHookTransaction;
+}
+interface AfterBulkCreateHookArgs<TModel extends Record<string, unknown>> {
+  records: TModel[];
+  model: ModelHookModel<TModel>;
+  manager: ModelWriteHookManager<TModel>;
+  transaction?: ModelWriteHookTransaction;
+}
+/**
+ * Async-capable model-owned write lifecycle hooks.
+ *
+ * Use model hooks for persistence rules that should apply everywhere the model
+ * is written, including serializers, viewsets, scripts, and direct manager
+ * calls.
+ */
+interface ModelWriteHooks<TModel extends Record<string, unknown>> {
+  beforeCreate?(args: BeforeCreateHookArgs<TModel>): Promise<Partial<TModel> | void> | Partial<TModel> | void;
+  afterCreate?(args: AfterCreateHookArgs<TModel>): Promise<void> | void;
+  beforeUpdate?(args: BeforeUpdateHookArgs<TModel>): Promise<Partial<TModel> | void> | Partial<TModel> | void;
+  afterUpdate?(args: AfterUpdateHookArgs<TModel>): Promise<void> | void;
+  beforeDelete?(args: BeforeDeleteHookArgs<TModel>): Promise<void> | void;
+  afterDelete?(args: AfterDeleteHookArgs<TModel>): Promise<void> | void;
+  beforeBulkCreate?(args: BeforeBulkCreateHookArgs<TModel>): Promise<Partial<TModel>[] | void> | Partial<TModel>[] | void;
+  afterBulkCreate?(args: AfterBulkCreateHookArgs<TModel>): Promise<void> | void;
+}
+//#endregion
+//#region src/model/decorators/domain/DecoratedFieldKind.d.ts
+declare const InternalDecoratedFieldKind: {
+  readonly FOREIGN_KEY: "foreignKey";
+  readonly ONE_TO_ONE: "oneToOne";
+  readonly MANY_TO_MANY: "manyToMany";
+};
+type DecoratedFieldKind = (typeof InternalDecoratedFieldKind)[keyof typeof InternalDecoratedFieldKind];
+//#endregion
+//#region src/model/decorators/domain/ZodTypeAny.d.ts
+type ZodTypeAny = z.ZodTypeAny;
+//#endregion
+//#region src/model/decorators/domain/RelationDecoratedSchema.d.ts
+declare const TANGO_DECORATED_FIELD_KIND: unique symbol;
+type RelationDecoratedSchema<TSchema extends ZodTypeAny, TKind extends DecoratedFieldKind, TTargetModel extends Model | never = never, TName extends string | undefined = undefined, TRelatedName extends string | undefined = undefined> = TSchema & {
+  readonly [TANGO_DECORATED_FIELD_KIND]: {
+    readonly relationKind: TKind;
+    readonly targetModel: TTargetModel;
+    readonly name: TName;
+    readonly relatedName: TRelatedName;
+  };
+  readonly __tangoRelationDecoratedSchema: {
+    readonly relationKind: TKind;
+    readonly targetModel: TTargetModel;
+    readonly name: TName;
+    readonly relatedName: TRelatedName;
+  };
+};
+type RelationDecoratedSchemaKind<TField> = TField extends {
+  readonly __tangoRelationDecoratedSchema: {
+    readonly relationKind: infer TKind extends DecoratedFieldKind;
+  };
+} ? TKind : never;
+//#endregion
+//#region src/domain/Model.d.ts
+declare const MODEL_AUGMENTATION_SCHEMA: unique symbol;
+declare const MODEL_KEY: unique symbol;
+type ModelAugmentationCarrier<TSchema extends z.ZodObject<z.ZodRawShape>> = {
+  readonly [MODEL_AUGMENTATION_SCHEMA]?: TSchema;
+};
+type ModelKeyCarrier<TKey extends string> = {
+  readonly [MODEL_KEY]?: TKey;
+};
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+declare global {
+  interface TangoSchemaModelAugmentations<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>, TKey extends string = string> {}
+}
+type ManyToManyFieldKeys<TShape extends z.ZodRawShape> = { [K in keyof TShape]: IsAny<TShape[K]> extends true ? never : [RelationDecoratedSchemaKind<TShape[K]>] extends [never] ? never : [RelationDecoratedSchemaKind<TShape[K]>] extends [typeof InternalDecoratedFieldKind.MANY_TO_MANY] ? K : never }[keyof TShape];
+type PersistedShape<TShape extends z.ZodRawShape> = Omit<z.output<z.ZodObject<TShape>>, ManyToManyFieldKeys<TShape>>;
+type PersistedModelOutput<TSchema extends z.ZodObject<z.ZodRawShape>> = TSchema extends z.ZodObject<infer TShape> ? PersistedShape<TShape> : z.output<TSchema>;
+interface ModelAugmentations<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>, TKey extends string = string> extends ModelAugmentationCarrier<TSchema>, ModelKeyCarrier<TKey>, TangoSchemaModelAugmentations<TSchema, TKey> {}
+interface Model<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>, TKey extends string = string> extends ModelAugmentations<TSchema, TKey> {
+  metadata: ModelMetadata;
+  schema: TSchema;
+  /**
+   * Model-owned write lifecycle hooks preserved from the definition.
+   */
+  hooks?: ModelWriteHooks<PersistedModelOutput<TSchema>>;
+}
+type ModelKeyOf<TModel> = TModel extends Model<z.ZodObject<z.ZodRawShape>, infer TKey> ? TKey : never;
+declare namespace index_d_exports {
+  export { AfterBulkCreateHookArgs, AfterCreateHookArgs, AfterDeleteHookArgs, AfterUpdateHookArgs, BeforeBulkCreateHookArgs, BeforeCreateHookArgs, BeforeDeleteHookArgs, BeforeUpdateHookArgs, DeleteReferentialAction, Field, FieldType, IndexDef, Model, ModelAugmentations, ModelHookModel, ModelKeyOf, ModelMetadata, ModelWriteHookManager, ModelWriteHookOnCommitOptions, ModelWriteHookTransaction, ModelWriteHooks, PersistedModelOutput, RelationDef, RelationType, UpdateReferentialAction };
+}
+//#endregion
+export { FieldType as A, ModelMetadata as C, RelationType as D, Field as E, UpdateReferentialAction as O, ModelWriteHooks as S, IndexDef as T, BeforeUpdateHookArgs as _, PersistedModelOutput as a, ModelWriteHookOnCommitOptions as b, DecoratedFieldKind as c, AfterCreateHookArgs as d, AfterDeleteHookArgs as f, BeforeDeleteHookArgs as g, BeforeCreateHookArgs as h, ModelKeyOf as i, DeleteReferentialAction as k, InternalDecoratedFieldKind as l, BeforeBulkCreateHookArgs as m, Model as n, RelationDecoratedSchema as o, AfterUpdateHookArgs as p, ModelAugmentations as r, ZodTypeAny as s, index_d_exports as t, AfterBulkCreateHookArgs as u, ModelHookModel as v, RelationDef as w, ModelWriteHookTransaction as x, ModelWriteHookManager as y };
+//# sourceMappingURL=index-Bhh0b304.d.ts.map