pg-dump-parser 1.6.0 → 1.8.0

package/src/sortSchemaObjects.test.ts

@@ -0,0 +1,372 @@
+import { parsePgDump } from './parsePgDump';
+import {
+  groupAndSortSchemaObjects,
+  sortSchemaObjects,
+  sortSchemaObjectsByScope,
+} from './sortSchemaObjects';
+import multiline from 'multiline-ts';
+import { describe, expect, test } from 'vitest';
+
+describe('sortSchemaObjects', () => {
+  test('sorts schema objects by type order', () => {
+    const dump = multiline`
+      --
+      -- Name: foo; Type: TABLE; Schema: public; Owner: postgres
+      --
+      
+      CREATE TABLE public.foo (
+          id integer NOT NULL,
+          name text NOT NULL
+      );
+      
+      
+      --
+      -- Name: bar; Type: INDEX; Schema: public; Owner: postgres
+      --
+      
+      CREATE INDEX bar ON public.foo USING btree (name);
+      
+      
+      --
+      -- Name: baz; Type: EXTENSION; Schema: -; Owner: -
+      --
+      
+      CREATE EXTENSION IF NOT EXISTS baz;
+      
+      
+      --
+      -- Name: qux; Type: CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.foo
+          ADD CONSTRAINT qux PRIMARY KEY (id);
+    `;
+
+    const schemaObjects = parsePgDump(dump);
+    const sorted = sortSchemaObjects(schemaObjects);
+
+    // Extension should come first
+    expect(sorted[0].header).toMatchObject({ Name: 'baz', Type: 'EXTENSION' });
+    // Then table
+    expect(sorted[1].header).toMatchObject({ Name: 'foo', Type: 'TABLE' });
+    // Then constraint
+    expect(sorted[2].header).toMatchObject({ Name: 'qux', Type: 'CONSTRAINT' });
+    // Finally index
+    expect(sorted[3].header).toMatchObject({ Name: 'bar', Type: 'INDEX' });
+  });
+
+  test('sorts constraints by type (PRIMARY, UNIQUE, FOREIGN, CHECK)', () => {
+    const dump = multiline`
+      --
+      -- Name: foo foo_check; Type: CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.foo
+          ADD CONSTRAINT foo_check CHECK (id > 0);
+      
+      
+      --
+      -- Name: foo foo_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.foo
+          ADD CONSTRAINT foo_fkey FOREIGN KEY (bar_id) REFERENCES public.bar(id);
+      
+      
+      --
+      -- Name: foo foo_unique; Type: CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.foo
+          ADD CONSTRAINT foo_unique UNIQUE (name);
+      
+      
+      --
+      -- Name: foo foo_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.foo
+          ADD CONSTRAINT foo_pkey PRIMARY KEY (id);
+    `;
+
+    const schemaObjects = parsePgDump(dump);
+    const sorted = sortSchemaObjects(schemaObjects);
+
+    // Primary key should come first
+    expect(sorted[0].sql).toContain('PRIMARY KEY');
+    // Then unique
+    expect(sorted[1].sql).toContain('UNIQUE');
+    // Then check
+    expect(sorted[2].sql).toContain('CHECK');
+    // Finally foreign key
+    expect(sorted[3].sql).toContain('FOREIGN KEY');
+  });
+
+  test('sorts indexes alphabetically within the same table', () => {
+    const dump = multiline`
+      --
+      -- Name: foo; Type: TABLE; Schema: public; Owner: postgres
+      --
+      
+      CREATE TABLE public.foo (
+          id integer NOT NULL,
+          name text NOT NULL,
+          email text
+      );
+      
+      
+      --
+      -- Name: foo_name_idx; Type: INDEX; Schema: public; Owner: postgres
+      --
+      
+      CREATE INDEX foo_name_idx ON public.foo USING btree (name);
+      
+      
+      --
+      -- Name: foo_email_idx; Type: INDEX; Schema: public; Owner: postgres
+      --
+      
+      CREATE INDEX foo_email_idx ON public.foo USING btree (email);
+      
+      
+      --
+      -- Name: foo_id_idx; Type: INDEX; Schema: public; Owner: postgres
+      --
+      
+      CREATE INDEX foo_id_idx ON public.foo USING btree (id);
+    `;
+
+    const schemaObjects = parsePgDump(dump);
+    const sorted = sortSchemaObjects(schemaObjects);
+
+    const indexes = sorted.filter(
+      (object) => 'Type' in object.header && object.header.Type === 'INDEX',
+    );
+
+    expect(indexes[0].header).toMatchObject({ Name: 'foo_email_idx' });
+    expect(indexes[1].header).toMatchObject({ Name: 'foo_id_idx' });
+    expect(indexes[2].header).toMatchObject({ Name: 'foo_name_idx' });
+  });
+
+  test('sorts comments by type and target', () => {
+    const dump = multiline`
+      --
+      -- Name: COLUMN foo.name; Type: COMMENT; Schema: public; Owner: postgres
+      --
+      
+      COMMENT ON COLUMN public.foo.name IS 'Name column';
+      
+      
+      --
+      -- Name: TABLE foo; Type: COMMENT; Schema: public; Owner: postgres
+      --
+      
+      COMMENT ON TABLE public.foo IS 'Foo table';
+      
+      
+      --
+      -- Name: COLUMN foo.id; Type: COMMENT; Schema: public; Owner: postgres
+      --
+      
+      COMMENT ON COLUMN public.foo.id IS 'ID column';
+      
+      
+      --
+      -- Name: EXTENSION pgcrypto; Type: COMMENT; Schema: -; Owner: -
+      --
+      
+      COMMENT ON EXTENSION pgcrypto IS 'Crypto extension';
+    `;
+
+    const schemaObjects = parsePgDump(dump);
+    const sorted = sortSchemaObjects(schemaObjects);
+
+    const comments = sorted.filter(
+      (object) => 'Type' in object.header && object.header.Type === 'COMMENT',
+    );
+
+    // Extension comment first
+    expect(comments[0].header).toMatchObject({ Name: 'EXTENSION pgcrypto' });
+    // Then table comment
+    expect(comments[1].header).toMatchObject({ Name: 'TABLE foo' });
+    // Then column comments sorted by name
+    expect(comments[2].header).toMatchObject({ Name: 'COLUMN foo.id' });
+    expect(comments[3].header).toMatchObject({ Name: 'COLUMN foo.name' });
+  });
+
+  test('groups and sorts schema objects by scope', () => {
+    const dump = multiline`
+      --
+      -- Name: foo; Type: TABLE; Schema: public; Owner: postgres
+      --
+      
+      CREATE TABLE public.foo (
+          id integer NOT NULL,
+          name text NOT NULL
+      );
+      
+      
+      --
+      -- Name: foo_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.foo
+          ADD CONSTRAINT foo_pkey PRIMARY KEY (id);
+      
+      
+      --
+      -- Name: foo_name_idx; Type: INDEX; Schema: public; Owner: postgres
+      --
+      
+      CREATE INDEX foo_name_idx ON public.foo USING btree (name);
+      
+      
+      --
+      -- Name: bar; Type: TABLE; Schema: public; Owner: postgres
+      --
+      
+      CREATE TABLE public.bar (
+          id integer NOT NULL,
+          foo_id integer
+      );
+      
+      
+      --
+      -- Name: bar_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.bar
+          ADD CONSTRAINT bar_pkey PRIMARY KEY (id);
+      
+      
+      --
+      -- Name: bar_foo_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.bar
+          ADD CONSTRAINT bar_foo_id_fkey FOREIGN KEY (foo_id) REFERENCES public.foo(id);
+    `;
+
+    const schemaObjects = parsePgDump(dump);
+    const grouped = groupAndSortSchemaObjects(schemaObjects);
+
+    // Should have two groups for the two tables
+    const tableGroups = Array.from(grouped.keys()).filter((key) =>
+      key.includes('TABLE:'),
+    );
+    expect(tableGroups).toHaveLength(2);
+
+    // Each group should be sorted internally
+    for (const [key, objects] of grouped.entries()) {
+      if (key.includes('TABLE:public:foo')) {
+        // foo table group should have table, constraint, and index
+        expect(objects).toHaveLength(3);
+        expect(objects[0].header).toMatchObject({ Type: 'TABLE' });
+        expect(objects[1].header).toMatchObject({ Type: 'CONSTRAINT' });
+        expect(objects[2].header).toMatchObject({ Type: 'INDEX' });
+      } else if (key.includes('TABLE:public:bar')) {
+        // bar table group should have table and two constraints
+        expect(objects).toHaveLength(3);
+        expect(objects[0].header).toMatchObject({ Type: 'TABLE' });
+        expect(objects[1].header).toMatchObject({ Type: 'CONSTRAINT' });
+        expect(objects[2].header).toMatchObject({ Type: 'FK CONSTRAINT' });
+      }
+    }
+  });
+
+  test('sortSchemaObjectsByScope returns flat sorted array', () => {
+    const dump = multiline`
+      --
+      -- Name: foo; Type: TABLE; Schema: public; Owner: postgres
+      --
+      
+      CREATE TABLE public.foo (
+          id integer NOT NULL
+      );
+      
+      
+      --
+      -- Name: foo_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.foo
+          ADD CONSTRAINT foo_pkey PRIMARY KEY (id);
+      
+      
+      --
+      -- Name: bar; Type: TABLE; Schema: public; Owner: postgres
+      --
+      
+      CREATE TABLE public.bar (
+          id integer NOT NULL
+      );
+      
+      
+      --
+      -- Name: bar_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+      --
+      
+      ALTER TABLE ONLY public.bar
+          ADD CONSTRAINT bar_pkey PRIMARY KEY (id);
+    `;
+
+    const schemaObjects = parsePgDump(dump);
+    const sorted = sortSchemaObjectsByScope(schemaObjects);
+
+    expect(sorted).toHaveLength(4);
+
+    // Objects should be grouped by table
+    // First bar table and its constraint
+    expect(sorted[0].header).toMatchObject({ Name: 'bar', Type: 'TABLE' });
+    expect(sorted[1].header).toMatchObject({
+      Name: 'bar_pkey',
+      Type: 'CONSTRAINT',
+    });
+
+    // Then foo table and its constraint
+    expect(sorted[2].header).toMatchObject({ Name: 'foo', Type: 'TABLE' });
+    expect(sorted[3].header).toMatchObject({
+      Name: 'foo_pkey',
+      Type: 'CONSTRAINT',
+    });
+  });
+
+  test('handles schemas correctly in sorting', () => {
+    const dump = multiline`
+      --
+      -- Name: foo; Type: TABLE; Schema: custom; Owner: postgres
+      --
+      
+      CREATE TABLE custom.foo (
+          id integer NOT NULL
+      );
+      
+      
+      --
+      -- Name: foo; Type: TABLE; Schema: public; Owner: postgres
+      --
+      
+      CREATE TABLE public.foo (
+          id integer NOT NULL
+      );
+      
+      
+      --
+      -- Name: bar; Type: TABLE; Schema: -; Owner: postgres
+      --
+      
+      CREATE TABLE bar (
+          id integer NOT NULL
+      );
+    `;
+
+    const schemaObjects = parsePgDump(dump);
+    const sorted = sortSchemaObjects(schemaObjects);
+
+    // Tables with null schema should come first
+    expect(sorted[0].header).toMatchObject({ Name: 'bar', Schema: null });
+    // Then sorted by schema name
+    expect(sorted[1].header).toMatchObject({ Name: 'foo', Schema: 'custom' });
+    expect(sorted[2].header).toMatchObject({ Name: 'foo', Schema: 'public' });
+  });
+});

package/src/sortSchemaObjects.ts

@@ -0,0 +1,323 @@
+import { type AttributedHeader, type SchemaObject } from './parsePgDump';
+import { scopeSchemaObject } from './scopeSchemaObject';
+
+/**
+ * Sort order for different schema object types
+ */
+const TYPE_SORT_ORDER: Record<string, number> = {
+  // ACLs and other
+  ACL: 18,
+
+  AGGREGATE: 6,
+  CAST: 22,
+
+  // Comments
+  COMMENT: 17,
+  // Constraints (sorted by type)
+  CONSTRAINT: 11,
+  // Table modifications and defaults
+  DEFAULT: 10,
+
+  'DEFAULT ACL': 19,
+  // Extensions first
+  EXTENSION: 1,
+  'FK CONSTRAINT': 12,
+
+  // Functions and procedures
+  FUNCTION: 4,
+
+  // Indexes
+  INDEX: 13,
+  'MATERIALIZED VIEW': 15,
+
+  PROCEDURE: 5,
+
+  // Publications and casts
+  PUBLICATION: 21,
+  // Types and schemas
+  SCHEMA: 2,
+
+  SEQUENCE: 8,
+
+  'SEQUENCE OWNED BY': 9,
+
+  // Tables and sequences
+  TABLE: 7,
+  // Table attachments
+  'TABLE ATTACH': 20,
+
+  'TEXT SEARCH CONFIGURATION': 24,
+
+  // Text search
+  'TEXT SEARCH DICTIONARY': 23,
+  // Triggers
+  TRIGGER: 16,
+
+  TYPE: 3,
+  // Views
+  VIEW: 14,
+};
+
+/**
+ * Get the sort key for a constraint based on its type
+ */
+const getConstraintSortKey = (sql: string): string => {
+  const upperSql = sql.toUpperCase();
+
+  if (upperSql.includes('PRIMARY KEY')) {
+    return '1_PRIMARY';
+  } else if (upperSql.includes('UNIQUE')) {
+    return '2_UNIQUE';
+  } else if (upperSql.includes('FOREIGN KEY')) {
+    return '3_FOREIGN';
+  } else if (upperSql.includes('CHECK')) {
+    return '4_CHECK';
+  } else if (upperSql.includes('EXCLUDE')) {
+    return '5_EXCLUDE';
+  }
+
+  return '9_OTHER';
+};
+
+/**
+ * Compare two schema objects for sorting
+ */
+const compareSchemaObjects = (
+  a: SchemaObject,
+  b: SchemaObject,
+  schemaObjects: SchemaObject[],
+): number => {
+  // Handle non-attributed headers (like database dump headers)
+  if (!('Type' in a.header) && !('Type' in b.header)) {
+    return 0;
+  }
+
+  if (!('Type' in a.header)) {
+    return -1;
+  }
+
+  if (!('Type' in b.header)) {
+    return 1;
+  }
+
+  const aHeader = a.header as AttributedHeader;
+  const bHeader = b.header as AttributedHeader;
+
+  // First, sort by type order
+  const aTypeOrder = TYPE_SORT_ORDER[aHeader.Type] ?? 999;
+  const bTypeOrder = TYPE_SORT_ORDER[bHeader.Type] ?? 999;
+
+  if (aTypeOrder !== bTypeOrder) {
+    return aTypeOrder - bTypeOrder;
+  }
+
+  // For the same type, apply specific sorting rules
+
+  // Sort by schema first (null schemas come first)
+  const aSchema = aHeader.Schema ?? '';
+  const bSchema = bHeader.Schema ?? '';
+  if (aSchema !== bSchema) {
+    if (aSchema === '') {
+      return -1;
+    }
+
+    if (bSchema === '') {
+      return 1;
+    }
+
+    return aSchema.localeCompare(bSchema);
+  }
+
+  // Special handling for constraints
+  if (aHeader.Type === 'CONSTRAINT' || aHeader.Type === 'FK CONSTRAINT') {
+    // Extract table name from constraint name (format: "table constraint_name")
+    const aTableName = aHeader.Name.split(' ')[0];
+    const bTableName = bHeader.Name.split(' ')[0];
+
+    if (aTableName !== bTableName) {
+      return aTableName.localeCompare(bTableName);
+    }
+
+    // Within the same table, sort by constraint type
+    const aConstraintKey = getConstraintSortKey(a.sql);
+    const bConstraintKey = getConstraintSortKey(b.sql);
+
+    if (aConstraintKey !== bConstraintKey) {
+      return aConstraintKey.localeCompare(bConstraintKey);
+    }
+  }
+
+  // Special handling for indexes
+  if (aHeader.Type === 'INDEX') {
+    // Group indexes by their target table
+    const aScopeObject = scopeSchemaObject(schemaObjects, a);
+    const bScopeObject = scopeSchemaObject(schemaObjects, b);
+
+    if (aScopeObject && bScopeObject) {
+      const aTableName = aScopeObject.name;
+      const bTableName = bScopeObject.name;
+
+      if (aTableName !== bTableName) {
+        return aTableName.localeCompare(bTableName);
+      }
+    }
+  }
+
+  // Special handling for comments - sort by what they comment on
+  if (aHeader.Type === 'COMMENT') {
+    const aTarget = aHeader.Name;
+    const bTarget = bHeader.Name;
+
+    // Extract the type of comment (TABLE, COLUMN, etc.)
+    const aCommentType = aTarget.split(' ')[0];
+    const bCommentType = bTarget.split(' ')[0];
+
+    if (aCommentType !== bCommentType) {
+      // Define order for comment types
+      const commentTypeOrder: Record<string, number> = {
+        AGGREGATE: 6,
+        COLUMN: 8,
+        EXTENSION: 1,
+        FUNCTION: 4,
+        INDEX: 10,
+        MATERIALIZED: 12,
+        PROCEDURE: 5,
+        SCHEMA: 2,
+        SEQUENCE: 9,
+        TABLE: 7,
+        TYPE: 3,
+        VIEW: 11,
+      };
+
+      const aOrder = commentTypeOrder[aCommentType] ?? 999;
+      const bOrder = commentTypeOrder[bCommentType] ?? 999;
+
+      if (aOrder !== bOrder) {
+        return aOrder - bOrder;
+      }
+    }
+
+    // For COLUMN comments, sort by table name then column position
+    if (aCommentType === 'COLUMN') {
+      const aMatch = aTarget.match(/COLUMN\s+(\S+\.\S+)\.(.+)/u);
+      const bMatch = bTarget.match(/COLUMN\s+(\S+\.\S+)\.(.+)/u);
+
+      if (aMatch && bMatch) {
+        const aTable = aMatch[1];
+        const bTable = bMatch[1];
+
+        if (aTable !== bTable) {
+          return aTable.localeCompare(bTable);
+        }
+
+        // Same table, sort by column name
+        const aColumn = aMatch[2];
+        const bColumn = bMatch[2];
+
+        return aColumn.localeCompare(bColumn);
+      }
+    }
+  }
+
+  // Finally, sort by name
+  return aHeader.Name.localeCompare(bHeader.Name);
+};
+
+/**
+ * Groups schema objects by their scope (table, view, etc.) and sorts them
+ */
+export const groupAndSortSchemaObjects = (
+  schemaObjects: SchemaObject[],
+): Map<string, SchemaObject[]> => {
+  const grouped = new Map<string, SchemaObject[]>();
+
+  // First, group objects by their scope
+  for (const schemaObject of schemaObjects) {
+    const scope = scopeSchemaObject(schemaObjects, schemaObject);
+
+    let key: string;
+    if (scope) {
+      // Create a unique key for each scope
+      key = `${scope.type}:${scope.schema ?? 'null'}:${scope.name}`;
+    } else if ('Type' in schemaObject.header) {
+      // For objects without a scope, group by type
+      const header = schemaObject.header as AttributedHeader;
+      key = `_UNSCOPED:${header.Type}:${header.Schema ?? 'null'}:${header.Name}`;
+    } else {
+      // Title headers
+      key = '_TITLE';
+    }
+
+    if (!grouped.has(key)) {
+      grouped.set(key, []);
+    }
+
+    const groupArray = grouped.get(key);
+    if (groupArray) {
+      groupArray.push(schemaObject);
+    }
+  }
+
+  // Sort objects within each group
+  for (const objects of grouped.values()) {
+    objects.sort((a, b) => compareSchemaObjects(a, b, schemaObjects));
+  }
+
+  // Sort the groups themselves
+  const sortedGrouped = new Map(
+    // eslint-disable-next-line unicorn/no-array-sort
+    [...grouped.entries()].sort(([keyA], [keyB]) => {
+      // Title headers first
+      if (keyA === '_TITLE') {
+        return -1;
+      }
+
+      if (keyB === '_TITLE') {
+        return 1;
+      }
+
+      // Then unscoped objects
+      if (keyA.startsWith('_UNSCOPED:') && !keyB.startsWith('_UNSCOPED:')) {
+        return -1;
+      }
+
+      if (!keyA.startsWith('_UNSCOPED:') && keyB.startsWith('_UNSCOPED:')) {
+        return 1;
+      }
+
+      // Sort by type, schema, then name
+      return keyA.localeCompare(keyB);
+    }),
+  );
+
+  return sortedGrouped;
+};
+
+/**
+ * Sorts an array of schema objects
+ */
+export const sortSchemaObjects = (
+  schemaObjects: SchemaObject[],
+): SchemaObject[] => {
+  const sorted = [...schemaObjects];
+
+  sorted.sort((a, b) => compareSchemaObjects(a, b, schemaObjects));
+
+  return sorted;
+};
+
+/**
+ * Sorts schema objects while preserving their grouping by scope
+ */
+export const sortSchemaObjectsByScope = (
+  schemaObjects: SchemaObject[],
+): SchemaObject[] => {
+  const grouped = groupAndSortSchemaObjects(schemaObjects);
+  const result: SchemaObject[] = [];
+
+  for (const objects of grouped.values()) {
+    result.push(...objects);
+  }
+
+  return result;
+};