@metaobjectsdev/migrate-ts 1.0.1 → 1.0.3

package/src/snapshot/plan.ts

@@ -22,6 +22,15 @@ export interface PlanOfflineArgs extends Pick<DiffArgs, "allow" | "onAmbiguous"
    * loaded (unchanged behavior).
    */
   inScope?: ObjectScopePredicate;
+  /**
+   * FR-023 — objects a DEPENDENCY owns. Imported metadata is loaded so this project's
+   * own model can resolve against it and is governed by nobody here unless `inScope`
+   * admits it, so such an object leaves BOTH sides of the diff and, unlike an
+   * `inScope` exclusion, takes its database schema out of the run's scope with it
+   * (migrate-ts `scope.ts` header). Omit for a project with no dependencies
+   * (unchanged behavior).
+   */
+  imported?: ObjectScopePredicate;
 }
 
 export interface PlanOfflineResult {
@@ -41,8 +50,12 @@ export interface PlanOfflineResult {
    * only for what it governs.
    */
   expected: SchemaSnapshot;
-  /** Qualified physical names excluded by `inScope`; empty when no scope was given. */
+  /** Qualified physical names excluded by `inScope` OR by `imported`; empty when
+   *  neither was given. */
   outOfScope: readonly string[];
+  /** The subset of `outOfScope` a dependency contributed (FR-023), so the CLI can say
+   *  WHY those objects were excluded. `undefined` when no `imported` was given. */
+  importedOutOfScope: readonly string[] | undefined;
 }
 
 /**
@@ -58,6 +71,7 @@ export async function planOffline(args: PlanOfflineArgs): Promise<PlanOfflineRes
       ...(args.views !== undefined ? { views: args.views } : {}),
     }),
     args.inScope,
+    args.imported !== undefined ? { imported: args.imported } : undefined,
   );
   // The DIFF runs against the narrowed side; the SNAPSHOT keeps what this run
   // excluded. Committing the narrowed schema would delete every out-of-scope entry
@@ -82,7 +96,13 @@ export async function planOffline(args: PlanOfflineArgs): Promise<PlanOfflineRes
     ...(args.onAmbiguous ? { onAmbiguous: args.onAmbiguous } : {}),
     ...(args.ignoreTables ? { ignoreTables: args.ignoreTables } : {}),
   });
-  return { diff: result, nextSnapshot, expected: scoped.snapshot, outOfScope: scoped.outOfScope };
+  return {
+    diff: result,
+    nextSnapshot,
+    expected: scoped.snapshot,
+    outOfScope: scoped.outOfScope,
+    importedOutOfScope: scoped.importedOutOfScope,
+  };
 }
 
 /** Seed an initial reference snapshot from metadata (greenfield baseline). */

package/src/types.ts

@@ -233,7 +233,15 @@ export type Change =
   | { kind: "drop-column"; table: string; schema?: string; column: string; restore?: ColumnDescriptor; status: ChangeStatus }
   | { kind: "rename-column"; table: string; schema?: string; from: string; to: string; status: ChangeStatus }
   | { kind: "change-column-type"; table: string; schema?: string; column: string;
-      from: SqlType; to: SqlType; status: ChangeStatus }
+      from: SqlType; to: SqlType;
+      /** The column's live default and the default it should end with, when either exists.
+       *  Postgres converts a default with an ASSIGNMENT cast, never through USING, so a type
+       *  change that needs USING must drop the default first and set it after, which the
+       *  emitter can only do knowing both. A type change CARRIES its column's default change
+       *  rather than sitting beside a separate `change-column-default`, whose down would run
+       *  first and set the old default on a column still holding the new type. */
+      fromDefault?: ColumnDefault; toDefault?: ColumnDefault;
+      status: ChangeStatus }
   | { kind: "change-column-nullable"; table: string; schema?: string; column: string;
       from: boolean; to: boolean; status: ChangeStatus }
   | { kind: "change-column-default"; table: string; schema?: string; column: string;