peta-migrate 0.1.1 → 0.2.0

package/dist/index.d.mts

@@ -1,5 +1,28 @@
 import { Kysely } from "kysely";
+import { ModelDefinition } from "peta-orm";
 
+//#region src/checksum.d.ts
+interface ChecksumStore {
+  [name: string]: string;
+}
+/**
+ * Compute SHA-256 hex digest of a file's content.
+ */
+declare function computeChecksum(filePath: string): string;
+/**
+ * Load the checksum store from the migrations directory.
+ */
+declare function loadChecksums(migrationsDir: string): ChecksumStore;
+/**
+ * Save checksums to the migrations directory.
+ */
+declare function saveChecksums(migrationsDir: string, store: ChecksumStore): void;
+/**
+ * Verify a migration file's checksum against the stored value.
+ * Returns true if match or no stored checksum exists.
+ */
+declare function verifyChecksum(migrationsDir: string, name: string, filePath: string): boolean;
+//#endregion
 //#region src/types.d.ts
 interface MigrationFile {
   name: string;
@@ -24,393 +47,56 @@ interface ResolvedConfig {
   models: string[] | string;
   getKysely: () => Kysely<unknown>;
 }
-//#endregion
-//#region src/config.d.ts
-declare function defineConfig(config: PetaMigrateConfig): PetaMigrateConfig;
-declare function loadConfig(): Promise<ResolvedConfig>;
-declare function loadMigrationFiles(dir: string): Promise<MigrationFile[]>;
-//#endregion
-//#region ../orm/src/lib/kysely.d.ts
-type Database = Kysely<Record<string, never>>;
-//#endregion
-//#region ../orm/src/pagination/index.d.ts
-interface Paginator {
-  readonly data: Collection;
-  readonly total: number;
-  readonly perPage: number;
-  readonly currentPage: number;
-  readonly lastPage: number;
-  readonly hasMorePages: boolean;
-  readonly hasPages: boolean;
-  readonly firstItem: number;
-  readonly lastItem: number;
-  readonly onFirstPage: boolean;
-  readonly onLastPage: boolean;
-  readonly count: number;
-  map<T>(fn: (item: ModelInstance) => T): T[];
-  toJSON(): PaginatorJson;
-}
-interface PaginatorJson {
-  data: Record<string, unknown>[];
-  total: number;
-  perPage: number;
-  currentPage: number;
-  lastPage: number;
-  hasMorePages: boolean;
-  hasPages: boolean;
-  firstItem: number | null;
-  lastItem: number | null;
-  onFirstPage: boolean;
-  onLastPage: boolean;
-}
-//#endregion
-//#region ../orm/src/relations/base.d.ts
-type RelationType = "hasMany" | "belongsTo" | "hasOne" | "manyToMany" | "hasManyThrough";
-interface Relation {
-  readonly type: RelationType;
-  readonly relatedModelClass: ModelDefinition;
-  readonly foreignKey: string;
-  readonly localKey: string;
-  readonly throughTable?: string;
-  readonly foreignPivotKey?: string;
-  readonly relatedPivotKey?: string;
-  readonly throughForeignKey?: string;
-  readonly throughLocalKey?: string;
-  _morphMap?: Record<string, () => ModelDefinition>;
-  _morphType?: string;
-  _morphId?: string;
-  _morphTypeValue?: string;
-  query(parent: ModelInstance): QueryBuilder;
-  addEagerConstraints(query: QueryBuilder, models: ModelInstance[]): void;
-  match(models: ModelInstance[], results: ModelInstance[], relationName: string): void;
-  getResults(parent: ModelInstance): Promise<ModelInstance | ModelInstance[] | null>;
-  loadEager(models: ModelInstance[], relationName: string, constraints?: ((qb: QueryBuilder) => void) | null): Promise<void>;
+interface SchemaColumn {
+  name: string;
+  type: string;
+  isNullable: boolean;
+  isPrimaryKey: boolean;
+  isUnique: boolean;
+  defaultValue: unknown;
+  references?: {
+    table: string;
+    column: string;
+  };
 }
-//#endregion
-//#region ../orm/src/relations/graph/types.d.ts
-interface InsertGraphOptions {
-  /** Allow `#id` / `#ref` special properties in the graph */
-  allowRefs?: boolean;
-  /**
-   * If `true`, objects with an `id` property get related (pivot row / FK set)
-   * instead of inserted. Can be an array of relation names to scope.
-   */
-  relate?: boolean | string[];
-  /**
-   * Whitelist of relation paths allowed for this graph operation.
-   * Accepts an array of dotted paths or a Set. If not set, all relations are allowed.
-   * When used via the query builder, the QB's `allowGraph()` set is forwarded automatically.
-   */
-  allowGraph?: string[] | Set<string>;
+interface SchemaIndex {
+  name: string;
+  columns: string[];
+  unique?: boolean;
 }
-interface UpsertGraphOptions extends InsertGraphOptions {
-  /** Unrelate (set FK null / remove pivot) instead of deleting missing items */
-  unrelate?: boolean | string[];
-  /** Prevent deletion for all or specific relation paths */
-  noDelete?: boolean | string[];
-  /** Prevent insertion for all or specific relation paths */
-  noInsert?: boolean | string[];
-  /** Prevent update for all or specific relation paths */
-  noUpdate?: boolean | string[];
+interface SchemaTable {
+  name: string;
+  columns: SchemaColumn[];
+  indexes: SchemaIndex[];
 }
-//#endregion
-//#region ../orm/src/query/types.d.ts
-interface QueryBuilder extends PromiseLike<ModelInstance[]> {
-  execute(): Promise<ModelInstance[]>;
-  collect(): Promise<Collection>;
-  executeTakeFirst(): Promise<ModelInstance | undefined>;
-  executeTakeFirstOrThrow(): Promise<ModelInstance>;
-  find(id: number | string): Promise<ModelInstance | undefined>;
-  findOrFail(id: number | string): Promise<ModelInstance>;
-  first(): Promise<ModelInstance | undefined>;
-  toSQL(): {
-    sql: string;
-    parameters: readonly unknown[];
-  };
-  count(): Promise<number>;
-  sum(column: string): Promise<number>;
-  avg(column: string): Promise<number>;
-  min(column: string): Promise<number>;
-  max(column: string): Promise<number>;
-  withCount(relation: string): QueryBuilder;
-  withSum(relation: string, column: string): QueryBuilder;
-  withAvg(relation: string, column: string): QueryBuilder;
-  withMin(relation: string, column: string): QueryBuilder;
-  withMax(relation: string, column: string): QueryBuilder;
-  withExists(relation: string): QueryBuilder;
-  chunk(size: number, callback: (chunk: ModelInstance[]) => Promise<void>): Promise<void>;
-  paginate(page: number, perPage?: number): Promise<Paginator>;
-  insertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: InsertGraphOptions): Promise<any>;
-  upsertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: UpsertGraphOptions): Promise<any>;
-  with(...relations: (string | Record<string, (qb: QueryBuilder) => void>)[]): QueryBuilder;
-  /**
-   * Whitelist allowed relations (and nested paths) for eager loading.
-   * Throws if a relation path is not in the allow list.
-   *
-   * Supports dotted paths for granular control:
-   * - `allowGraph("posts")` allows `posts`, `posts.author`, `posts.author.profile`, etc.
-   * - `allowGraph("posts.author")` allows `posts.author` and `posts.author.profile`,
-   *   but NOT bare `posts` or `posts.comments`.
-   *
-   * Multiple arguments are merged: `allowGraph("posts", "profile")`
-   */
-  allowGraph(...expressions: string[]): QueryBuilder;
-  updateMany(data: Record<string, unknown>): Promise<number>;
-  deleteMany(): Promise<number>;
-  withTrashed(): QueryBuilder;
-  onlyTrashed(): QueryBuilder;
-  whereIn(column: string, values: unknown[]): QueryBuilder;
-  whereInPivot(column: string, values: unknown[]): QueryBuilder;
-  has(relationName: string): QueryBuilder;
-  whereHas(relationName: string, callback?: (qb: QueryBuilder) => void): QueryBuilder;
-  whereDoesntHave(relationName: string, callback?: (qb: QueryBuilder) => void): QueryBuilder;
-  where(column: string, operator: unknown, value?: unknown): QueryBuilder;
-  whereRef(col1: string, operator: string, col2: string): QueryBuilder;
-  orWhere(column: string, operator: unknown, value?: unknown): QueryBuilder;
-  orderBy(column: string, direction?: "asc" | "desc"): QueryBuilder;
-  limit(n: number): QueryBuilder;
-  offset(n: number): QueryBuilder;
-  select(...columns: string[]): QueryBuilder;
-  selectAll(table?: string): QueryBuilder;
-  innerJoin(table: string, lhs: string, rhs: string): QueryBuilder;
-  leftJoin(table: string, lhs: string, rhs: string): QueryBuilder;
-  groupBy(...columns: string[]): QueryBuilder;
-  having(column: string, operator: string, value: unknown): QueryBuilder;
-  withoutGlobalScope(name: string): QueryBuilder;
-  all(): QueryBuilder;
-  /** @internal Access underlying Kysely builder for raw SQL operations */
-  _getKyselyQb(): any;
-  /** @internal Replace the underlying Kysely builder */
-  _replaceKyselyQb(newQb: any): void;
-  when(condition: unknown, callback: (q: QueryBuilder) => QueryBuilder): QueryBuilder;
-  unless(condition: unknown, callback: (q: QueryBuilder) => QueryBuilder): QueryBuilder;
+interface SchemaSnapshot {
+  version: 1;
+  tables: SchemaTable[];
 }
-//#endregion
-//#region ../orm/src/relations/related-query.d.ts
-interface RelationQuery extends QueryBuilder {
-  /** Attach related model(s) for many-to-many relations. */
-  attach(ids: number | number[] | string | string[], pivotData?: Record<string, unknown>): Promise<void>;
-  /** Detach related model(s) for many-to-many relations. */
-  detach(ids?: number | number[] | string | string[]): Promise<void>;
-  /** Sync related models: attaches new IDs, detaches missing ones. */
-  sync(ids: (number | string)[] | Record<number | string, Record<string, unknown>>): Promise<void>;
-  /** Sync without detaching existing IDs. */
-  syncWithoutDetaching(ids: (number | string)[]): Promise<void>;
-  /** Update pivot data for a specific related model. */
-  updateExistingPivot(id: number | string, data: Record<string, unknown>): Promise<void>;
+interface SchemaDiff {
+  type: "createTable" | "dropTable" | "addColumn" | "dropColumn" | "alterColumn" | "addIndex" | "dropIndex";
+  table: string;
+  column?: string;
+  details?: Record<string, unknown>;
 }
 //#endregion
-//#region ../orm/src/plugins/index.d.ts
+//#region src/config.d.ts
+declare function defineConfig(config: PetaMigrateConfig): PetaMigrateConfig;
+declare function loadConfig(): Promise<ResolvedConfig>;
+declare function loadMigrationFiles(dir: string): Promise<MigrationFile[]>;
 /**
- * A plugin is a function that receives a model definition and can
- * modify it by adding hooks, scopes, columns, or methods.
- *
- * ```ts
- * const myPlugin = (options?: MyOptions): Plugin =>
- *   (def) => {
- *     def.addGlobalScope?.('active', (q) => q.where('active', true))
- *     return def
- *   }
- * ```
+ * Load model definitions from glob patterns.
+ * Dynamically imports each matched file and collects ModelDefinition exports.
+ * Models are keyed by their `.name` property.
  */
-type Plugin = (def: ModelDefinition) => undefined | ModelDefinition;
-//#endregion
-//#region ../orm/src/columns/schema.d.ts
-interface Constraint {
-  type: string;
-  args: unknown[];
-}
-//#endregion
-//#region ../orm/src/columns/column.d.ts
-interface Column<out T = unknown> {
-  readonly arkType: unknown;
-  readonly dataType: string;
-  readonly args: readonly unknown[];
-  readonly constraints: readonly Constraint[];
-  readonly isNullable: boolean;
-  readonly isPrimaryKey: boolean;
-  readonly isUnique: boolean;
-  readonly defaultValue: unknown;
-  hasConstraint(type: string): boolean;
-  parse(value: unknown): T;
-  assert(value: unknown): T;
-  primaryKey(): Column<T>;
-  nullable(): Column<T | null>;
-  default<V>(value: V): Column<T>;
-  unique(): Column<T>;
-  index(): Column<T>;
-  min(n: number): Column<T>;
-  max(n: number): Column<T>;
-  email(): Column<T>;
-  url(): Column<T>;
-  pattern(regex: RegExp | string): Column<T>;
-  references(table: () => unknown, columns: string[]): Column<T>;
-}
-type ColumnShape = Record<string, Column>;
-//#endregion
-//#region ../orm/src/types.d.ts
-interface ModelLike {
-  get<T = unknown>(key: string): T;
-  set(key: string, value: unknown): void;
-}
-interface ORMLike {
-  readonly kysely: Database;
-  register(model: ModelDefinition$1<any>): void;
-  registerAll(...models: (ModelDefinition$1<any> | ModelDefinition$1<any>[])[]): void;
-  destroy(): Promise<void>;
-  transaction<T>(fn: (trx: import("kysely").Kysely<Record<string, never>>) => Promise<T>): Promise<T>;
-  readonly models: ReadonlyMap<string, ModelDefinition$1<any>>;
-  getModel<T extends ColumnShape = ColumnShape>(name: string): ModelDefinition$1<T> | undefined;
-}
-interface ModelDefinition$1<TColumns extends ColumnShape = ColumnShape> {
-  readonly table: string;
-  readonly columns: TColumns;
-  readonly relations: Record<string, Relation>;
-  readonly name: string;
-  _orm: ORMLike | null;
-  query(): QueryBuilder;
-  find(id: number | string): Promise<ModelInstance | undefined>;
-  findOrFail(id: number | string): Promise<ModelInstance>;
-  first(): Promise<ModelInstance | undefined>;
-  create(data: Record<string, unknown>): Promise<ModelInstance>;
-  insert(data: Record<string, unknown>): Promise<ModelInstance>;
-  insertMany(dataArray: Record<string, unknown>[]): Promise<ModelInstance[]>;
-  update(id: number | string, data: Record<string, unknown>): Promise<ModelInstance>;
-  delete(id: number | string): Promise<void>;
-  hydrate(row: Record<string, unknown>): ModelInstance;
-  on(event: string, callback: (model: ModelInstance) => void | Promise<void>): () => void;
-  getHooks(): HookManager;
-  addGlobalScope(name: string, callback: (qb: QueryBuilder) => void): void;
-  removeGlobalScope(name: string): void;
-  getGlobalScopes(): Map<string, (qb: QueryBuilder) => void> | undefined;
-  _init(orm: ORMLike): void;
-}
-//#endregion
-//#region ../orm/src/hooks/index.d.ts
-type LifecycleEvent = "beforeCreate" | "afterCreate" | "beforeUpdate" | "afterUpdate" | "beforeSave" | "afterSave" | "beforeDelete" | "afterDelete" | "beforeRestore" | "afterRestore" | "beforeForceDelete" | "afterForceDelete";
-type HookCallback = (model: ModelLike) => void | Promise<void>;
-interface HookManager {
-  on(event: LifecycleEvent, callback: HookCallback): () => void;
-  off(event: LifecycleEvent, callback: HookCallback): void;
-  trigger(event: LifecycleEvent, model: ModelLike): Promise<void>;
-  clone(): HookManager;
-}
-//#endregion
-//#region ../orm/src/hooks/static.d.ts
-interface StaticHookArgs {
-  /** Transform the mutating query into a SELECT to preview affected rows */
-  asFindQuery(): QueryBuilder;
-  /** Cancel the mutation and return a custom result */
-  cancelQuery(result: unknown): void;
-  /** The column data being inserted/updated (for create/update hooks) */
-  inputItems?: Record<string, unknown>[];
-}
-type StaticHookCallback = (args: StaticHookArgs) => void | Promise<void>;
+declare function loadModels(patterns: string | string[]): Promise<Map<string, ModelDefinition>>;
 //#endregion
-//#region ../orm/src/model/types.d.ts
-interface ModelInstance {
-  readonly exists: boolean;
-  readonly attributes: Record<string, unknown>;
-  readonly dirtyAttributes: Record<string, unknown>;
-  isDirty(key?: string): boolean;
-  get<T = unknown>(key: string): T;
-  set(key: string, value: unknown): void;
-  fill(data: Record<string, unknown>): void;
-  reset(): void;
-  $getRelation<T = unknown>(name: string): T;
-  $setRelation(name: string, value: unknown): void;
-  $hasRelation(name: string): boolean;
-  $relationData(): Record<string, unknown>;
-  $load(...relations: string[]): Promise<void>;
-  $related(name: string): RelationQuery;
-  $save(): Promise<this>;
-  $delete(): Promise<void>;
-  $forceDelete(): Promise<void>;
-  $restore(): Promise<void>;
-  $trashed(): boolean;
-  $reload(): Promise<void>;
-  $toJSON(): Record<string, unknown>;
-  toJSON(): Record<string, unknown>;
-}
-interface ModelDefinition<TColumns extends ColumnShape = ColumnShape> {
-  readonly table: string;
-  readonly columns: TColumns;
-  readonly relations: Record<string, Relation>;
-  readonly name: string;
-  _orm: ORMLike | null;
-  query(): QueryBuilder;
-  find(id: number | string): Promise<ModelInstance | undefined>;
-  findOrFail(id: number | string): Promise<ModelInstance>;
-  first(): Promise<ModelInstance | undefined>;
-  create(data: Record<string, unknown>): Promise<ModelInstance>;
-  insert(data: Record<string, unknown>): Promise<ModelInstance>;
-  insertMany(dataArray: Record<string, unknown>[]): Promise<ModelInstance[]>;
-  update(id: number | string, data: Record<string, unknown>): Promise<ModelInstance>;
-  delete(id: number | string): Promise<void>;
-  insertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: InsertGraphOptions): Promise<any>;
-  upsertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: UpsertGraphOptions): Promise<any>;
-  hydrate(row: Record<string, unknown>): ModelInstance;
-  use(plugin: Plugin): ModelDefinition;
-  makeHelper<A extends any[], R>(fn: (qb: QueryBuilder, ...args: A) => R): (...args: A) => R;
-  on(event: string, callback: (model: ModelInstance) => void | Promise<void>): () => void;
-  getHooks(): HookManager;
-  beforeDelete(callback: StaticHookCallback): () => void;
-  afterDelete(callback: StaticHookCallback): () => void;
-  beforeUpdate(callback: StaticHookCallback): () => void;
-  afterUpdate(callback: StaticHookCallback): () => void;
-  beforeCreate(callback: StaticHookCallback): () => void;
-  afterCreate(callback: StaticHookCallback): () => void;
-  beforeFind(callback: StaticHookCallback): () => void;
-  afterFind(callback: StaticHookCallback): () => void;
-  addGlobalScope(name: string, callback: (qb: QueryBuilder) => void): void;
-  removeGlobalScope(name: string): void;
-  getGlobalScopes(): Map<string, (qb: QueryBuilder) => void> | undefined;
-  registerTimestamps?(createdAtCol?: string, updatedAtCol?: string): void;
-  registerSoftDeletes?(deletedAtCol?: string): void;
-  discover?(): Promise<never>;
-  _init(orm: ORMLike): void;
-}
-//#endregion
-//#region ../orm/src/collection/index.d.ts
-interface Collection {
-  readonly length: number;
-  [Symbol.iterator](): Iterator<ModelInstance>;
-  at(index: number): ModelInstance | undefined;
-  first(): ModelInstance | undefined;
-  last(): ModelInstance | undefined;
-  all(): ModelInstance[];
-  findBy(id: number | string): ModelInstance | undefined;
-  find(callback: (item: ModelInstance, index: number) => boolean): ModelInstance | undefined;
-  some(callback: (item: ModelInstance, index: number) => boolean): boolean;
-  includes(item: ModelInstance): boolean;
-  isEmpty(): boolean;
-  isNotEmpty(): boolean;
-  get(key: string): unknown[];
-  pluck(key: string): unknown[];
-  groupBy(key: string): Record<string, ModelInstance[]>;
-  keyBy(key: string): Record<string, ModelInstance>;
-  map<T>(fn: (item: ModelInstance, index: number) => T): T[];
-  filter(fn: (item: ModelInstance, index: number) => boolean): Collection;
-  reduce<T>(fn: (acc: T, item: ModelInstance, index: number) => T, initial: T): T;
-  forEach(fn: (item: ModelInstance, index: number) => void): void;
-  each(fn: (item: ModelInstance, index: number) => void): Collection;
-  unique(key?: string): Collection;
-  sortBy(key: string, direction?: "asc" | "desc"): Collection;
-  shuffle(): Collection;
-  take(n: number): Collection;
-  skip(n: number): Collection;
-  chunk(size: number): Collection[];
-  sum(key: string): number;
-  avg(key: string): number;
-  min(key: string): number;
-  max(key: string): number;
-  diff(other: Collection): Collection;
-  intersect(other: Collection): Collection;
-  concat(other: Collection): Collection;
-  push(...items: ModelInstance[]): void;
-  load(...relations: string[]): Promise<Collection>;
-  toJSON(): Record<string, unknown>[];
-}
+//#region src/differ.d.ts
+/**
+ * Compare two SchemaSnapshots and produce a list of SchemaDiff operations.
+ * Compares `prev` (old) vs `next` (new) to generate a migration plan.
+ */
+declare function diffSnapshots(prev: SchemaSnapshot, next: SchemaSnapshot): SchemaDiff[];
 //#endregion
 //#region src/generator.d.ts
 interface GeneratorOptions {
@@ -418,9 +104,18 @@ interface GeneratorOptions {
 }
 interface MigrationGenerator {
   generateInitialMigration(models: Map<string, ModelDefinition>, options?: GeneratorOptions): string;
+  generateMigrationFromDiff(diffs: SchemaDiff[], options?: GeneratorOptions): string;
 }
 declare function createMigrationGenerator(): MigrationGenerator;
 //#endregion
+//#region src/pusher.d.ts
+/**
+ * Push current model schema directly to the database.
+ * Creates tables and columns that don't exist yet (no destructive changes).
+ * Returns list of tables that were created.
+ */
+declare function pushSchema(db: Kysely<unknown>, models: Map<string, ModelDefinition>): Promise<string[]>;
+//#endregion
 //#region src/runner.d.ts
 interface MigrationRunner {
   ensureTable(): Promise<void>;
@@ -431,4 +126,18 @@ interface MigrationRunner {
 }
 declare function createMigrationRunner(db: Kysely<Record<string, never>>, table?: string): MigrationRunner;
 //#endregion
-export { type GeneratorOptions, type MigrationFile, type MigrationGenerator, type MigrationRecord, type MigrationRunner, type MigrationStatus, type PetaMigrateConfig, type ResolvedConfig, createMigrationGenerator, createMigrationRunner, defineConfig, loadConfig, loadMigrationFiles };
+//#region src/snapshot.d.ts
+/**
+ * Extract a SchemaSnapshot from a map of model definitions.
+ */
+declare function createSnapshot(models: Map<string, ModelDefinition>): SchemaSnapshot;
+/**
+ * Load snapshot from a JSON file path.
+ */
+declare function loadSnapshot(filePath: string): Promise<SchemaSnapshot | null>;
+/**
+ * Save snapshot to a JSON file path.
+ */
+declare function saveSnapshot(filePath: string, snapshot: SchemaSnapshot): Promise<void>;
+//#endregion
+export { type GeneratorOptions, type MigrationFile, type MigrationGenerator, type MigrationRecord, type MigrationRunner, type MigrationStatus, type PetaMigrateConfig, type ResolvedConfig, type SchemaColumn, type SchemaDiff, type SchemaIndex, type SchemaSnapshot, type SchemaTable, computeChecksum, createMigrationGenerator, createMigrationRunner, createSnapshot, defineConfig, diffSnapshots, loadChecksums, loadConfig, loadMigrationFiles, loadModels, loadSnapshot, pushSchema, saveChecksums, saveSnapshot, verifyChecksum };

package/dist/index.mjs

@@ -1,2 +1,3 @@
-import { a as loadMigrationFiles, i as loadConfig, n as createMigrationGenerator, r as defineConfig, t as createMigrationRunner } from "./runner-DOQsuaSQ.mjs";
-export { createMigrationGenerator, createMigrationRunner, defineConfig, loadConfig, loadMigrationFiles };
+import { t as pushSchema } from "./pusher-DJvKHlOT.mjs";
+import { a as createMigrationGenerator, c as loadConfig, d as computeChecksum, f as loadChecksums, i as createMigrationRunner, l as loadMigrationFiles, m as verifyChecksum, n as loadSnapshot, o as diffSnapshots, p as saveChecksums, r as saveSnapshot, s as defineConfig, t as createSnapshot, u as loadModels } from "./snapshot-DopEB8mx.mjs";
+export { computeChecksum, createMigrationGenerator, createMigrationRunner, createSnapshot, defineConfig, diffSnapshots, loadChecksums, loadConfig, loadMigrationFiles, loadModels, loadSnapshot, pushSchema, saveChecksums, saveSnapshot, verifyChecksum };

package/dist/pusher-DJvKHlOT.mjs

@@ -0,0 +1,88 @@
+//#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
+//#region src/pusher.ts
+var pusher_exports = /* @__PURE__ */ __exportAll({ pushSchema: () => pushSchema });
+/**
+* Push current model schema directly to the database.
+* Creates tables and columns that don't exist yet (no destructive changes).
+* Returns list of tables that were created.
+*/
+async function pushSchema(db, models) {
+	const createdTables = [];
+	for (const [, model] of models) {
+		if (!model.table) continue;
+		if (await tableExists(db, model.table)) continue;
+		const qb = db.schema.createTable(model.table).ifNotExists();
+		const columns = model.columns;
+		for (const [name, col] of Object.entries(columns)) qb.addColumn(name, mapPushType(col), (cb) => buildColumn(col, cb));
+		await qb.execute();
+		createdTables.push(model.table);
+		for (const [colName, col] of Object.entries(columns)) if (col.hasConstraint("index") && !col.isPrimaryKey && !col.isUnique) await db.schema.createIndex(`${model.table}_${colName}_index`).on(model.table).column(colName).execute();
+	}
+	return createdTables;
+}
+async function tableExists(db, name) {
+	try {
+		return (await db.introspection.getTables({ withInternalKyselyTables: true })).some((t) => t.name === name);
+	} catch {
+		return false;
+	}
+}
+function buildColumn(col, cb) {
+	if (col.isPrimaryKey) {
+		if (col.dataType === "integer") cb = cb.autoIncrement();
+		cb = cb.primaryKey();
+	}
+	if (!col.isNullable && !col.isPrimaryKey) cb = cb.notNull();
+	if (col.defaultValue !== void 0 && typeof col.defaultValue !== "function") cb = cb.defaultTo(col.defaultValue);
+	if (col.isUnique && !col.isPrimaryKey) cb = cb.unique();
+	const refConstraint = col.constraints.find((c) => c.type === "references");
+	if (refConstraint?.args[0]) {
+		const targetTable = (typeof refConstraint.args[0] === "function" ? refConstraint.args[0]() : refConstraint.args[0])?.table;
+		const targetColumns = refConstraint.args[1];
+		if (typeof targetTable === "string" && targetTable && targetColumns?.length) {
+			const first = targetColumns[0];
+			if (first) cb = cb.references(`${targetTable}.${first}`);
+		}
+	}
+	return cb;
+}
+function mapPushType(col) {
+	switch (col.dataType) {
+		case "integer":
+		case "smallint":
+		case "bigint":
+		case "text":
+		case "boolean":
+		case "timestamp":
+		case "date":
+		case "float":
+		case "double":
+		case "uuid": return col.dataType;
+		case "string": {
+			const max = col.args[0];
+			return max != null ? `varchar(${max})` : "varchar";
+		}
+		case "json":
+		case "jsonb": return "json";
+		case "decimal": {
+			const p = col.args[0];
+			const s = col.args[1];
+			return p != null ? `decimal(${p}, ${s ?? 0})` : "decimal";
+		}
+		case "enum": return "text";
+		default: return col.dataType;
+	}
+}
+//#endregion
+export { pusher_exports as n, pushSchema as t };