@axinom/mosaic-cli 0.14.2-rc.8 → 0.15.0-rc.0

package/src/commands/publish-schema-to-db/pg-models/columns/fk-column.spec.ts

@@ -0,0 +1,42 @@
+import { PgColumn, PgTable, PgType } from '../../abstractions';
+import { FkColumn } from './fk-column';
+
+interface FkColumnTestInput {
+  pkType: PgType;
+  expectedExpression: string;
+}
+
+const testData: [string, FkColumnTestInput][] = [
+  [
+    'FK for TEXT PK',
+    {
+      pkType: 'TEXT',
+      expectedExpression: 'entity_id TEXT REFERENCES entity ON DELETE CASCADE',
+    },
+  ],
+  [
+    'FK for INTEGER PK',
+    {
+      pkType: 'INTEGER',
+      expectedExpression:
+        'entity_id INTEGER REFERENCES entity ON DELETE CASCADE',
+    },
+  ],
+];
+describe('FkColumn', () => {
+  test.each(testData)('%s', (description: string, input: FkColumnTestInput) => {
+    // Arrange
+    const entityTablePk: PgColumn = {
+      name: 'id',
+      type: input.pkType,
+      table: { name: 'entity' } as PgTable,
+    } as PgColumn;
+    const propertyTable: PgTable = { name: 'object' } as PgTable;
+    const fk = new FkColumn(entityTablePk, propertyTable);
+    const expectedFkName = `${fk.table.name}_${fk.name}_fkey`;
+
+    // Act & Assert
+    expect(fk.buildExpression()).toBe(input.expectedExpression);
+    expect(fk.fkName).toBe(expectedFkName);
+  });
+});

package/src/commands/publish-schema-to-db/pg-models/columns/fk-column.ts

@@ -0,0 +1,41 @@
+import {
+  BaseSmartTags,
+  PgColumn,
+  PgFkColumn,
+  PgTable,
+  PgType,
+} from '../../abstractions';
+import { buildName } from '../pg-sql-gen-utils';
+
+export class FkColumn implements PgFkColumn {
+  name: string;
+  readonly table: PgTable;
+  readonly type: PgType;
+  readonly referencedPk: PgColumn;
+  readonly targetPk: PgColumn;
+  readonly fkName: string;
+
+  /**
+   * Constructor for FkColumn.
+   * @param targetPk - PK to the 'target' table.
+   * @param table - Reference to the parent table.
+   */
+  constructor(targetPk: PgColumn, table: PgTable) {
+    this.targetPk = targetPk;
+    this.name = buildName(targetPk.table.name, targetPk.name);
+    this.table = table;
+    this.fkName = buildName(table.name, this.name, 'fkey');
+    this.type = targetPk.type;
+    this.referencedPk = targetPk;
+  }
+  buildSmartTags(): BaseSmartTags {
+    return {};
+  }
+
+  buildExpression(): string {
+    return `${this.name} ${this.type} REFERENCES ${this.referencedPk.table.name} ON DELETE CASCADE`;
+  }
+  buildAdditionalStatements(): string[] {
+    return [`CREATE INDEX ON ${this.table.buildFullName()} (${this.name})`];
+  }
+}

package/src/commands/publish-schema-to-db/pg-models/columns/index.ts

@@ -0,0 +1,4 @@
+export * from './fk-column';
+export * from './pk-column';
+export * from './primitive-column';
+export * from './virtual-fk-column';

package/src/commands/publish-schema-to-db/pg-models/columns/pk-column.spec.ts

@@ -0,0 +1,47 @@
+import { PgTable, PgType } from '../../abstractions';
+import { PkColumn } from './pk-column';
+
+interface PkColumnTestInput {
+  type: PgType;
+  expectedExpression: string;
+}
+
+const dummyTable: PgTable = {} as PgTable;
+
+const testData: [string, PkColumnTestInput][] = [
+  [
+    'PK with TEXT type',
+    { type: 'TEXT', expectedExpression: 'id TEXT PRIMARY KEY' },
+  ],
+  [
+    'PK with INTEGER type',
+    {
+      type: 'INTEGER',
+      expectedExpression:
+        'id INTEGER PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY',
+    },
+  ],
+];
+
+describe('PkColumn', () => {
+  test.each(testData)('%s', (description: string, input: PkColumnTestInput) => {
+    // Arrange
+    const pkColumn = new PkColumn(dummyTable, input.type);
+
+    // Act & Assert
+    expect(pkColumn.buildExpression()).toBe(input.expectedExpression);
+  });
+
+  test('PK column with unsupported type throws', () => {
+    // Arrange
+    const unsupportedType: PgType = 'BOOLEAN';
+
+    // Act
+    const action = (): void => {
+      new PkColumn(dummyTable, unsupportedType);
+    };
+
+    // Assert
+    expect(action).toThrow(TypeError);
+  });
+});

package/src/commands/publish-schema-to-db/pg-models/columns/pk-column.ts

@@ -0,0 +1,34 @@
+import { BaseSmartTags, PgColumn, PgTable, PgType } from '../../abstractions';
+
+export class PkColumn implements PgColumn {
+  name: string;
+  readonly table: PgTable;
+  readonly type: PgType;
+
+  constructor(table: PgTable, type: PgType) {
+    if (type !== 'INTEGER' && type !== 'TEXT') {
+      throw new TypeError(`Type ${type} not supported as primary key.`);
+    }
+
+    this.name = 'id';
+    this.table = table;
+    this.type = type;
+  }
+  buildSmartTags(): BaseSmartTags {
+    return {};
+  }
+
+  buildAdditionalStatements(): string[] {
+    return [];
+  }
+
+  buildExpression(): string {
+    let sql = `${this.name} ${this.type} PRIMARY KEY`;
+
+    if (this.type === 'INTEGER') {
+      sql = `${sql} GENERATED BY DEFAULT AS IDENTITY`;
+    }
+
+    return sql;
+  }
+}

package/src/commands/publish-schema-to-db/pg-models/columns/primitive-column.spec.ts

@@ -0,0 +1,65 @@
+import { PgTable } from '../../abstractions';
+import { PrimitiveColumn } from './primitive-column';
+
+const dummyTable: PgTable = {
+  name: 'some_table',
+  buildFullName: () => 'schema.some_table',
+} as PgTable;
+
+describe('PrimitiveColumn', () => {
+  test('Default constructor', () => {
+    // Arrange & Act
+    const column = new PrimitiveColumn('some_column', 'TEXT', dummyTable);
+
+    // Assert
+    expect(column.buildExpression()).toBe('some_column TEXT');
+  });
+
+  test('Options with extraParams', () => {
+    // Arrange & Act
+    const column = new PrimitiveColumn('some_column', 'TEXT', dummyTable, {
+      extraParams: 'NOT NULL',
+    });
+
+    // Assert
+    expect(column.buildExpression()).toBe('some_column TEXT NOT NULL');
+  });
+
+  test('Options with indexable', () => {
+    // Arrange & Act
+    const column = new PrimitiveColumn('some_column', 'TEXT', dummyTable, {
+      indexable: true,
+    });
+
+    // Assert
+    expect(column.buildAdditionalStatements()).toEqual([
+      'CREATE INDEX ON schema.some_table (some_column)',
+    ]);
+  });
+
+  test('Options with description', () => {
+    // Arrange & Act
+    const column = new PrimitiveColumn('some_column', 'TEXT', dummyTable, {
+      description: 'some description',
+    });
+
+    // Assert
+    expect(column.buildSmartTags()).toEqual({
+      description: 'some description',
+    });
+  });
+
+  test('Setting a display name', () => {
+    // Arrange
+    const column = new PrimitiveColumn('some_column', 'TEXT', dummyTable);
+
+    // Act
+    column.displayName = 'column';
+
+    // Assert
+    expect(column.buildSmartTags()).toEqual({
+      description: undefined,
+      tags: { name: 'column' },
+    });
+  });
+});

package/src/commands/publish-schema-to-db/pg-models/columns/primitive-column.ts

@@ -0,0 +1,62 @@
+import { BaseSmartTags, PgColumn, PgTable, PgType } from '../../abstractions';
+
+export interface PrimitiveColumnOptions {
+  description?: string;
+  indexable?: boolean;
+  extraParams?: string;
+}
+
+/**
+ * Database column of primitive type.
+ */
+export class PrimitiveColumn implements PgColumn {
+  name: string;
+  displayName?: string;
+  readonly description?: string;
+  readonly table: PgTable;
+  readonly type: PgType;
+  private columnOptions?: PrimitiveColumnOptions;
+
+  constructor(
+    name: string,
+    type: PgType,
+    table: PgTable,
+    options?: PrimitiveColumnOptions,
+  ) {
+    this.name = name;
+    this.description = options?.description;
+    this.table = table;
+    this.type = type;
+    this.columnOptions = options;
+  }
+
+  buildExpression(): string {
+    const baseExpression = `${this.name} ${this.type}`;
+    if (this.columnOptions?.extraParams) {
+      return `${baseExpression} ${this.columnOptions.extraParams}`;
+    }
+
+    return baseExpression;
+  }
+
+  buildAdditionalStatements(): string[] {
+    if (this.columnOptions?.indexable) {
+      return [`CREATE INDEX ON ${this.table.buildFullName()} (${this.name})`];
+    }
+    return [];
+  }
+
+  buildSmartTags(): BaseSmartTags {
+    const tags: BaseSmartTags = {
+      description: this.description,
+    };
+
+    if (this.displayName) {
+      tags.tags = {
+        name: this.displayName,
+      };
+    }
+
+    return tags;
+  }
+}

package/src/commands/publish-schema-to-db/pg-models/columns/virtual-fk-column.spec.ts

@@ -0,0 +1,24 @@
+import { PgColumn, PgTable } from '../../abstractions';
+import { VirtualFkColumn } from './virtual-fk-column';
+
+describe('VirtualFkColumn', () => {
+  test('Virtual FK is created with correct references', () => {
+    // Arrange & Act
+    const entityTablePk: PgColumn = {
+      name: 'id',
+      type: 'TEXT',
+      table: { name: 'entity' } as PgTable,
+    } as PgColumn;
+    const relationsTable: PgTable = {
+      name: 'entity_relation',
+      buildFullName: () => 'schema.entity_relation',
+    } as PgTable;
+    const virtualFkColumn = new VirtualFkColumn(entityTablePk, relationsTable);
+
+    // Assert
+    expect(virtualFkColumn.buildExpression()).toBe('entity_id TEXT');
+    expect(virtualFkColumn.buildAdditionalStatements()).toEqual([
+      'CREATE INDEX ON schema.entity_relation (entity_id)',
+    ]);
+  });
+});

package/src/commands/publish-schema-to-db/pg-models/columns/virtual-fk-column.ts

@@ -0,0 +1,34 @@
+import {
+  BaseSmartTags,
+  PgColumn,
+  PgFkColumn,
+  PgTable,
+  PgType,
+} from '../../abstractions';
+import { buildName } from '../pg-sql-gen-utils';
+
+export class VirtualFkColumn implements PgFkColumn {
+  name: string;
+  readonly table: PgTable;
+  readonly type: PgType;
+  readonly additionalStatements: string[] = [];
+  readonly targetPk: PgColumn;
+
+  constructor(targetPk: PgColumn, table: PgTable) {
+    this.targetPk = targetPk;
+    this.name = buildName(targetPk.table.name, targetPk.name);
+    // Right now we just assume that all content types have the same PK type.
+    this.type = targetPk.type;
+    this.table = table;
+  }
+  buildSmartTags(): BaseSmartTags {
+    return {};
+  }
+  buildExpression(): string {
+    return `${this.name} ${this.type}`;
+  }
+
+  buildAdditionalStatements(): string[] {
+    return [`CREATE INDEX ON ${this.table.buildFullName()} (${this.name})`];
+  }
+}

package/src/commands/publish-schema-to-db/pg-models/json-schema-parse-utils.spec.ts

@@ -0,0 +1,182 @@
+import { JSONSchema4 } from 'json-schema';
+import { PgType } from '../abstractions';
+import { getPropertySchema, mapToPgType } from './json-schema-parse-utils';
+
+describe('mapToPgType', () => {
+  interface TestInput {
+    schemaJson: string;
+    expectedPgType: PgType;
+  }
+
+  // I wish there was a better way - https://github.com/facebook/jest/issues/6413
+  const testData: [string, TestInput][] = [
+    [
+      'parse integer',
+      {
+        schemaJson: `
+      {
+        "$schema": "http://json-schema.org/draft-04/schema",
+        "properties": {
+          "prop":{
+            "type": "integer"
+          }
+        }
+      }
+      `,
+        expectedPgType: 'INTEGER',
+      },
+    ],
+    [
+      'parse integer array',
+      {
+        schemaJson: `
+      {
+        "$schema": "http://json-schema.org/draft-04/schema",
+        "properties": {
+            "prop": {
+                "type": "array",
+                "items": {
+                  "type": "integer"
+                }
+            }
+        }
+      }
+      `,
+        expectedPgType: 'INTEGER[]',
+      },
+    ],
+    [
+      'parse string',
+      {
+        schemaJson: `
+      {
+          "$schema": "http://json-schema.org/draft-04/schema",
+          "properties": {
+              "prop": {
+                  "type": "string"
+              }
+          }
+      }
+      `,
+        expectedPgType: 'TEXT',
+      },
+    ],
+    [
+      'parse string array',
+      {
+        schemaJson: `
+      {
+          "$schema": "http://json-schema.org/draft-04/schema",
+          "properties": {
+              "prop": {
+                  "type": "array",
+                  "items": {
+                      "type": "string"
+                  }
+              }
+          }
+      }
+      `,
+        expectedPgType: 'TEXT[]',
+      },
+    ],
+    [
+      'parse boolean',
+      {
+        schemaJson: `
+      {
+          "$schema": "http://json-schema.org/draft-04/schema",
+          "properties": {
+              "prop": {
+                  "type": "boolean"
+              }
+          }
+      }
+      `,
+        expectedPgType: 'BOOLEAN',
+      },
+    ],
+    [
+      'parse date',
+      {
+        schemaJson: `
+      {
+          "$schema": "http://json-schema.org/draft-04/schema",
+          "properties": {
+              "prop": {
+                  "type": "string",
+                  "format": "date-time"
+              }
+          }
+      }
+      `,
+        expectedPgType: 'TIMESTAMPTZ',
+      },
+    ],
+  ];
+
+  test.each(testData)('%s', (description: string, input: TestInput) => {
+    // Arrange
+    const schema = JSON.parse(input.schemaJson) as JSONSchema4;
+
+    // Act
+    const pgType = mapToPgType(getPropertySchema(schema, 'prop'));
+
+    // Assert
+    expect(pgType).toBe(input.expectedPgType);
+  });
+});
+
+describe('getPropertySchema', () => {
+  test('Returns existing property', () => {
+    // Arrange
+    const schema = JSON.parse(`
+      {
+        "$schema": "http://json-schema.org/draft-04/schema",
+        "properties": {
+          "prop":{
+            "type": "integer"
+          }
+        }
+      }`) as JSONSchema4;
+
+    // Act
+    const propertySchema = getPropertySchema(schema, 'prop');
+
+    // Assert
+    expect(propertySchema).toBeDefined();
+  });
+
+  test('Throws if properties are not defined', () => {
+    // Arrange
+    const schema = JSON.parse(`
+      {
+        "$schema": "http://json-schema.org/draft-04/schema"
+      }`) as JSONSchema4;
+
+    // Act
+    const action = () => getPropertySchema(schema, 'prop');
+
+    // Assert
+    expect(action).toThrow(Error);
+  });
+
+  test('Returns undefined if property does not exist', () => {
+    // Arrange
+    const schema = JSON.parse(`
+      {
+        "$schema": "http://json-schema.org/draft-04/schema",
+        "properties": {
+          "prop":{
+            "type": "integer"
+          }
+        }
+      }`) as JSONSchema4;
+
+    // Act
+    const propertySchema = getPropertySchema(schema, 'does_not_exist');
+
+    // Assert
+    expect(propertySchema).toBeUndefined();
+  });
+});