peta-migrate 0.1.0

package/dist/cli.d.mts

@@ -0,0 +1,4 @@
+//#region src/cli.d.ts
+declare function run(): Promise<void>;
+//#endregion
+export { run };

package/dist/cli.mjs

@@ -0,0 +1,74 @@
+import { a as loadMigrationFiles, i as loadConfig, n as createMigrationGenerator, t as createMigrationRunner } from "./runner-DOQsuaSQ.mjs";
+import { resolve } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import cac from "cac";
+import ora from "ora";
+//#region src/cli.ts
+async function run() {
+	const cli = cac("peta");
+	cli.command("migrate:init", "Create migrations directory and tracking table").action(async () => {
+		const config = await loadConfig();
+		const spinner = ora("Setting up migrations...").start();
+		mkdirSync(config.migrationsDir, { recursive: true });
+		await createMigrationRunner(config.getKysely()).ensureTable();
+		spinner.succeed(`Migrations directory created at ${config.migrationsDir}`);
+	});
+	cli.command("migrate:generate [name]", "Generate initial migration from models").action(async (name) => {
+		const config = await loadConfig();
+		const spinner = ora("Generating migration...").start();
+		const code = createMigrationGenerator().generateInitialMigration(/* @__PURE__ */ new Map(), { name: name ?? "Initial" });
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+		const safeName = (name ?? "initial").replace(/[^a-zA-Z0-9_]/g, "_");
+		const filename = resolve(config.migrationsDir, `${timestamp}_${safeName}.ts`);
+		mkdirSync(config.migrationsDir, { recursive: true });
+		writeFileSync(filename, code);
+		spinner.succeed(`Created ${filename}`);
+	});
+	cli.command("migrate:up", "Apply pending migrations").action(async () => {
+		const config = await loadConfig();
+		const migrations = await loadMigrationFiles(config.migrationsDir);
+		if (migrations.length === 0) {
+			console.log("No migration files found.");
+			return;
+		}
+		const runner = createMigrationRunner(config.getKysely());
+		const status = await runner.status(migrations);
+		if (status.pending.length === 0) {
+			console.log("All migrations have been applied.");
+			return;
+		}
+		const spinner = ora(`Running ${status.pending.length} migration(s)...`).start();
+		await runner.up(migrations);
+		spinner.succeed(`Applied ${(await runner.getCompleted()).length} migration(s)`);
+	});
+	cli.command("migrate:down", "Rollback last batch").action(async () => {
+		const config = await loadConfig();
+		const migrations = await loadMigrationFiles(config.migrationsDir);
+		if (migrations.length === 0) {
+			console.log("No migration files found.");
+			return;
+		}
+		const runner = createMigrationRunner(config.getKysely());
+		if ((await runner.getCompleted()).length === 0) {
+			console.log("Nothing to rollback.");
+			return;
+		}
+		const spinner = ora("Rolling back...").start();
+		await runner.down(migrations);
+		spinner.succeed("Rolled back");
+	});
+	cli.command("migrate:status", "Show migration status").action(async () => {
+		const config = await loadConfig();
+		const migrations = await loadMigrationFiles(config.migrationsDir);
+		const { completed, pending } = await createMigrationRunner(config.getKysely()).status(migrations);
+		console.log(`\n  Completed: ${completed.length}`);
+		for (const m of completed) console.log(`    ✓ ${m.name}`);
+		console.log(`\n  Pending: ${pending.length}`);
+		for (const m of pending) console.log(`    · ${m.name}`);
+		console.log();
+	});
+	cli.help();
+	cli.parse();
+}
+//#endregion
+export { run };

package/dist/index.d.mts

@@ -0,0 +1,434 @@
+import { Kysely } from "kysely";
+
+//#region src/types.d.ts
+interface MigrationFile {
+  name: string;
+  up: (db: Kysely<unknown>) => Promise<void>;
+  down: (db: Kysely<unknown>) => Promise<void>;
+}
+interface MigrationRecord {
+  name: string;
+  appliedAt: string;
+}
+interface MigrationStatus {
+  completed: MigrationRecord[];
+  pending: MigrationFile[];
+}
+interface PetaMigrateConfig {
+  migrationsDir: string;
+  models: string[] | string;
+  getKysely: () => Kysely<unknown>;
+}
+interface ResolvedConfig {
+  migrationsDir: string;
+  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>;
+}
+//#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 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[];
+}
+//#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;
+}
+//#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>;
+}
+//#endregion
+//#region ../orm/src/plugins/index.d.ts
+/**
+ * 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
+ *   }
+ * ```
+ */
+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>;
+//#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>[];
+}
+//#endregion
+//#region src/generator.d.ts
+interface GeneratorOptions {
+  name?: string;
+}
+interface MigrationGenerator {
+  generateInitialMigration(models: Map<string, ModelDefinition>, options?: GeneratorOptions): string;
+}
+declare function createMigrationGenerator(): MigrationGenerator;
+//#endregion
+//#region src/runner.d.ts
+interface MigrationRunner {
+  ensureTable(): Promise<void>;
+  getCompleted(): Promise<MigrationRecord[]>;
+  up(migrations: MigrationFile[]): Promise<void>;
+  down(migrations: MigrationFile[]): Promise<void>;
+  status(migrations: MigrationFile[]): Promise<MigrationStatus>;
+}
+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 };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+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 };

package/dist/runner-DOQsuaSQ.mjs

@@ -0,0 +1,180 @@
+import { resolve } from "node:path";
+import { sql } from "kysely";
+//#region src/config.ts
+function defineConfig(config) {
+	return config;
+}
+async function loadConfig() {
+	const candidates = [
+		"peta.config.ts",
+		"peta.config.js",
+		"peta.config.mjs"
+	];
+	let mod = null;
+	for (const file of candidates) try {
+		mod = await import(resolve(process.cwd(), file));
+		break;
+	} catch {}
+	if (!mod) throw new Error("No peta.config.ts found. Create one in your project root.");
+	const config = mod.default ?? mod;
+	return {
+		migrationsDir: config.migrationsDir,
+		models: config.models,
+		getKysely: config.getKysely
+	};
+}
+async function loadMigrationFiles(dir) {
+	const { readdirSync } = await import("node:fs");
+	const files = readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
+	const migrations = [];
+	for (const file of files) {
+		const mod = await import(resolve(dir, file));
+		if (mod.up) migrations.push({
+			name: file.replace(/\.(ts|js)$/, ""),
+			up: mod.up,
+			down: mod.down ?? (async () => {})
+		});
+	}
+	return migrations;
+}
+//#endregion
+//#region src/generator.ts
+function createMigrationGenerator() {
+	function generateInitialMigration(models, options = {}) {
+		options.name;
+		const parts = [];
+		const indexParts = [];
+		const warnings = [];
+		const registeredTables = new Set([...models.values()].map((m) => m.table).filter(Boolean));
+		for (const [, modelDef] of models) {
+			const table = modelDef.table;
+			if (!table) continue;
+			parts.push(generateCreateTable(table, modelDef.columns));
+			for (const [colName, col] of Object.entries(modelDef.columns)) if (col.hasConstraint("index") && !col.isPrimaryKey && !col.isUnique) indexParts.push(generateCreateIndex(table, colName));
+			for (const [, rel] of Object.entries(modelDef.relations ?? {})) if (rel.type === "manyToMany") {
+				const through = rel.throughTable;
+				if (through && !registeredTables.has(through)) warnings.push(`// ⚠ Detected ManyToMany "${modelDef.name}" references table "${through}" but no model is registered for it.\n//   Add a model to include the pivot table.`);
+			}
+		}
+		const upBody = [...parts, ...indexParts].join("\n\n");
+		const downTables = [...models.values()].filter((m) => m.table).map((m) => `  await db.schema.dropTable("${m.table}").ifExists().execute()`).join("\n");
+		return `import type { Kysely } from "kysely"\nimport { sql } from "kysely"\n\nexport async function up(db: Kysely<any>): Promise<void> {\n${warnings.length > 0 ? `  // Warnings:\n${warnings.join("\n")}\n\n` : ""}${upBody}\n}\n\nexport async function down(db: Kysely<any>): Promise<void> {\n${downTables}\n}\n`;
+	}
+	return { generateInitialMigration };
+}
+function generateCreateTable(table, columns) {
+	const lines = [`  await db.schema.createTable("${table}").ifNotExists()`];
+	for (const [name, col] of Object.entries(columns)) lines.push(`    .addColumn("${name}", "${mapType(col)}"${columnCallback(col)})`);
+	lines.push("    .execute()");
+	return lines.join("\n");
+}
+function generateCreateIndex(table, column) {
+	return [
+		`  await db.schema.createIndex("${table}_${column}_index")`,
+		`    .on("${table}")`,
+		`    .column("${column}")`,
+		"    .execute()"
+	].join("\n");
+}
+function columnCallback(col) {
+	const calls = [];
+	if (col.isPrimaryKey) {
+		if (col.dataType === "integer") calls.push("autoIncrement()");
+		calls.push("primaryKey()");
+	}
+	if (!col.isNullable && !col.isPrimaryKey) calls.push("notNull()");
+	const dv = col.defaultValue;
+	if (dv !== void 0 && typeof dv !== "function") calls.push(`defaultTo(${JSON.stringify(dv)})`);
+	if (col.isUnique && !col.isPrimaryKey) calls.push("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) calls.push(`references("${targetTable}.${targetColumns[0]}")`);
+	}
+	return calls.length === 0 ? "" : `, (c) => c.${calls.join(".")}`;
+}
+function mapType(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
+//#region src/runner.ts
+function createMigrationRunner(db, table = "_peta_migrations") {
+	async function ensureTable() {
+		await db.schema.createTable(table).ifNotExists().addColumn("name", "varchar", (c) => c.notNull().primaryKey()).addColumn("applied_at", "timestamp", (c) => c.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+	}
+	async function getCompleted() {
+		try {
+			return (await db.selectFrom(table).select(["name", "applied_at"]).orderBy("name", "asc").execute()).map((r) => ({
+				name: String(r.name),
+				appliedAt: String(r.applied_at)
+			}));
+		} catch {
+			return [];
+		}
+	}
+	async function up(migrations) {
+		await ensureTable();
+		const completed = await getCompleted();
+		const completedNames = new Set(completed.map((r) => r.name));
+		for (const m of migrations.filter((m) => !completedNames.has(m.name)).sort(byName)) {
+			await m.up(db);
+			await db.insertInto(table).values({
+				name: m.name,
+				applied_at: (/* @__PURE__ */ new Date()).toISOString()
+			}).execute();
+		}
+	}
+	async function down(migrations) {
+		const completed = await getCompleted();
+		if (completed.length === 0 || migrations.length === 0) return;
+		for (const m of migrations.filter((m) => completed.some((r) => r.name === m.name)).sort(byName).reverse()) {
+			await m.down(db);
+			await db.deleteFrom(table).where("name", "=", m.name).execute();
+		}
+	}
+	async function status(migrations) {
+		const completed = await getCompleted();
+		const completedNames = new Set(completed.map((r) => r.name));
+		return {
+			completed,
+			pending: migrations.filter((m) => !completedNames.has(m.name)).sort(byName)
+		};
+	}
+	return {
+		ensureTable,
+		getCompleted,
+		up,
+		down,
+		status
+	};
+}
+function byName(a, b) {
+	return a.name.localeCompare(b.name);
+}
+//#endregion
+export { loadMigrationFiles as a, loadConfig as i, createMigrationGenerator as n, defineConfig as r, createMigrationRunner as t };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "peta-migrate",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Migration tools for peta-orm",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zfadhli/peta-stack.git"
+  },
+  "module": "src/index.ts",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "bin": {
+    "peta": "./bin/peta"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "cac": "^7.0.0",
+    "ora": "^9.4.0"
+  },
+  "peerDependencies": {
+    "kysely": "^0.28.17",
+    "typescript": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "tsdown": "^0.22.2"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "bun run build",
+    "typecheck": "bun x tsc --noEmit"
+  }
+}