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

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

@@ -0,0 +1,166 @@
+import { glob } from 'glob';
+import { JSONSchema4 } from 'json-schema';
+import { dereference } from 'json-schema-ref-parser';
+import { PgType } from '../abstractions';
+
+/**
+ * Returns true if a JSON schema property element is a primitive property.
+ * @remarks
+ * A primitive property is considered to be a property whose type is either
+ * a primitive type or an array of primitive type.
+ * @param schema - Schema element to analyze.
+ */
+export function isPrimitiveProperty(schema: JSONSchema4): boolean {
+  if (schema.type === 'array') {
+    return isPrimitiveType((schema.items as JSONSchema4)?.type);
+  }
+  return isPrimitiveType(schema.type);
+}
+
+/**
+ * Returns true if a JSON schema property element is an object property.
+ * @remarks
+ * An object property is considered to be a property whose type is either
+ * of type object or an array of type object.
+ * @param schema - Schema element to analyze.
+ */
+export function isObjectProperty(schema: JSONSchema4): boolean {
+  if (schema.type === 'array') {
+    return (schema.items as JSONSchema4)?.type === 'object';
+  }
+  return schema.type === 'object';
+}
+
+/**
+ * Returns true if schema property type is a primitive.
+ * @param typeName - Type name to check.
+ */
+export function isPrimitiveType(typeName: unknown): boolean {
+  return (
+    typeName === 'integer' ||
+    typeName === 'number' ||
+    typeName === 'string' ||
+    typeName === 'boolean'
+  );
+}
+
+/**
+ * Returns a property (defined in 'properties') schema by name from JSON schema.
+ * @param schema - JSON schema where the property exists.
+ * @param propertyName - Name of the property to extract.
+ */
+export function getPropertySchema(
+  schema: JSONSchema4,
+  propertyName: string,
+): JSONSchema4 {
+  if (schema.properties !== undefined) {
+    return schema.properties[propertyName];
+  }
+  throw new Error(`No properties are defined in the schema.`);
+}
+
+/**
+ * Maps JSON schema's property type to a Postgres type.
+ * @param schema - Property schema.
+ * @throws If the schema property type is not supported.
+ */
+export function mapToPgType(schema: JSONSchema4): PgType {
+  const isArray = schema.type === 'array';
+  schema = isArray ? (schema?.items as JSONSchema4) : schema;
+
+  if (schema.type === 'string') {
+    return mapString(schema, isArray);
+  }
+  if (schema.type === 'integer') {
+    return isArray ? 'INTEGER[]' : 'INTEGER';
+  }
+  if (schema.type === 'boolean') {
+    return 'BOOLEAN';
+  }
+
+  throw new TypeError(`Unknown primitive type ${schema.type}`);
+}
+
+function mapString(schema: JSONSchema4, isArray: boolean): PgType {
+  if (schema.format === 'date-time') {
+    return 'TIMESTAMPTZ';
+  }
+  if (isArray) {
+    return 'TEXT[]';
+  }
+  return 'TEXT';
+}
+
+/**
+ * Returns an array of all defined content metadata schemas (movie, collection etc.).
+ * @param schema - Publish message schema.
+ */
+export async function getContentMetadataSchemas(
+  schemaGlob: string,
+): Promise<JSONSchema4[]> {
+  const files = glob.sync(schemaGlob);
+  const schemas: JSONSchema4[] = [];
+  for (const file of files) {
+    const schema = (await dereference(file)) as JSONSchema4;
+    schemas.push(schema);
+  }
+  return schemas;
+}
+
+/**
+ * Separates primitive properties from object properties.
+ * @param schema - Content metadata schema.
+ * @param ignoredProperties - Array of ignored properties.
+ * @returns Tuple of separated properties: first element will be primitive properties, second object properties.
+ */
+export function separateProperties(
+  schema: JSONSchema4,
+  ignoredProperties: string[],
+): [{ [p: string]: JSONSchema4 }, { [p: string]: JSONSchema4 }] {
+  const primitiveProperties: { [p: string]: JSONSchema4 } = {};
+  const objectProperties: { [p: string]: JSONSchema4 } = {};
+
+  // 1. Extract primitive properties and create a ContentEntityTable
+  for (const key in schema.properties) {
+    if (ignoredProperties.includes(key)) {
+      continue;
+    }
+
+    const property = schema.properties[key] as JSONSchema4;
+    if (isPrimitiveProperty(property)) {
+      primitiveProperties[key] = property;
+    } else if (isObjectProperty(property)) {
+      objectProperties[key] = property;
+    } else {
+      throw new TypeError(`Unsupported property in asset schema: ${property}`);
+    }
+  }
+
+  return [primitiveProperties, objectProperties];
+}
+
+/**
+ * Filters out properties by name from a dictionary of JSON schema properties.
+ * @param schemas - Dictionary of schemas.
+ * @param excluded - Array of excluded names.
+ */
+export function filterProperties(
+  schemas: { [p: string]: JSONSchema4 },
+  excluded: string[],
+): { [p: string]: JSONSchema4 } {
+  const included = Object.keys(schemas).filter((k) => excluded.indexOf(k) < 0);
+
+  return included.reduce((obj, key) => ({ ...obj, [key]: schemas[key] }), {});
+}
+
+/**
+ * Returns schema's title, throws if it is undefined.
+ * @param schema - JSON schema
+ */
+export function getSchemaTitle(schema: JSONSchema4): string {
+  if (schema.title) {
+    return schema.title;
+  }
+
+  throw new Error('Schema title not set.');
+}

package/src/commands/publish-schema-to-db/pg-models/pg-sql-gen-utils.spec.ts

@@ -0,0 +1,19 @@
+import { buildName } from './pg-sql-gen-utils';
+
+describe('buildName', () => {
+  test('single part', () => {
+    // Arrange & Act
+    const name = buildName('name');
+
+    // Assert
+    expect(name).toBe('name');
+  });
+
+  test('multiple parts', () => {
+    // Arrange & Act
+    const name = buildName('new', 'name');
+
+    // Assert
+    expect(name).toBe('new_name');
+  });
+});

package/src/commands/publish-schema-to-db/pg-models/pg-sql-gen-utils.ts

@@ -0,0 +1,237 @@
+/* eslint-disable no-console */
+import * as fs from 'fs';
+import * as path from 'path';
+import { format } from 'sql-formatter';
+import { PgColumn, PgTable } from '../abstractions';
+import { ContentEntityModel } from '../content-entity-model';
+
+export function buildFullTableName(tableName: string, schema?: string): string {
+  return schema ? `${schema}.${tableName}` : tableName;
+}
+
+/**
+ * Builds a DROP TABLE IF EXISTS statement.
+ * @param table
+ */
+export function buildDropTableIfExists(table: PgTable): string {
+  return `DROP TABLE IF EXISTS ${table.buildFullName()} CASCADE`;
+}
+
+/**
+ * Builds a CREATE TABLE statement.
+ * @param table - PgTable instance to build the CREATE TABLE statement for.
+ */
+export function buildCreateTable(table: PgTable): string {
+  const columns = [
+    table.pk,
+    ...table.fks,
+    ...table.virtualFks,
+    ...table.columns,
+  ];
+  return `CREATE TABLE ${table.buildFullName()}(
+        ${columns.map((c) => c.buildExpression()).join(',\n')}
+    )`;
+}
+
+/**
+ * Builds a GRANT statement for INSERTs and UPDATEs.
+ * @param table - PgTable instance to build the GRANT statement for.
+ */
+export function buildInsertUpdateGrants(table: PgTable): string {
+  const columns = [...table.fks, ...table.virtualFks, ...table.columns];
+  return `GRANT INSERT, UPDATE (${columns.map((c) => c.name).join(',')})
+    ON ${table.buildFullName()} TO ":DATABASE_GQL_ROLE";`;
+}
+
+/**
+ * Builds a GRANT statement for SELECTs and DELETEs.
+ * @param table - PgTable instance to build the GRANT statement for.
+ */
+export function buildSelectDeleteGrants(table: PgTable): string {
+  return `GRANT SELECT, DELETE ON ${table.buildFullName()} TO ":DATABASE_GQL_ROLE";`;
+}
+
+/**
+ * Builds additional statements relevant for table creation
+ * that should be executed after CRATE TABLE e.g. adding indexes or comments.
+ * @param table - PgTable instance to build extra statements for.
+ */
+export function buildAdditionalTableStatements(table: PgTable): string[] {
+  const statements: string[] = [];
+  const columns = [
+    table.pk,
+    ...table.fks,
+    ...table.virtualFks,
+    ...table.columns,
+  ];
+
+  const additionalStatements = ([] as (string | undefined)[])
+    .concat(...columns.map((p) => p.buildAdditionalStatements()))
+    .filter((s: string | undefined): s is string => s !== undefined);
+
+  statements.push(...additionalStatements);
+
+  return statements;
+}
+
+/**
+ * Formats an SQL string using pg-formatter.
+ * @param sql - Input SQL string.
+ */
+export function formatSql(sql: string): string {
+  return format(sql, { language: 'sql' });
+}
+
+/**
+ * Generates a migration for graphile-migrate.
+ * @param statements - Array of SQL statements.
+ * @param outPath - Path where the dump is created.
+ */
+export async function generateMigration(
+  statements: string[],
+  outPath: string,
+): Promise<void> {
+  const dirPath = path.dirname(outPath);
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+
+  console.log(`Writing migration to ${outPath}.`);
+  const preamble = `
+    --! Message: added content types
+    -- Statements below are generated from publish format definitions.`;
+  statements.unshift(preamble);
+
+  fs.writeFile(outPath, formatSql(statements.join(';\n')), (err) => {
+    if (err) {
+      throw err;
+    }
+  });
+}
+
+/**
+ * Combines `nameParts` into a single snake case string.
+ * @param nameParts - Name parts to combine.
+ */
+export function buildName(...nameParts: string[]): string {
+  return nameParts.join('_');
+}
+
+export function renameDbItem(
+  item: PgTable | PgColumn,
+  newName: string,
+  displayName?: string,
+): void {
+  item.name = newName;
+  if (displayName) {
+    item.displayName = displayName;
+  }
+}
+
+export interface NameOverride {
+  [name: string]: [string, string?];
+}
+
+export function applyNameOverrides(
+  model: ContentEntityModel,
+  overrides: NameOverride,
+): void {
+  const mainModelTables = [model.contentEntity, ...model.relatedObjects];
+
+  for (const table of mainModelTables) {
+    let rename = overrides[table.name];
+    if (rename) {
+      renameDbItem(table, ...rename);
+    }
+    for (const column of table.columns) {
+      rename = overrides[column.name];
+      if (rename) {
+        renameDbItem(column, ...rename);
+      }
+    }
+  }
+}
+
+export function isReservedPgWord(s: string): boolean {
+  return PgReservedWords.includes(s.toUpperCase());
+}
+
+const PgReservedWords = [
+  'ALL',
+  'ANALYSE',
+  'ANALYZE',
+  'AND',
+  'ANY',
+  'ARRAY',
+  'AS',
+  'ASC',
+  'ASYMMETRIC',
+  'BOTH',
+  'CASE',
+  'CAST',
+  'CHECK',
+  'COLLATE',
+  'COLUMN',
+  'CONSTRAINT',
+  'CREATE',
+  'CURRENT_CATALOG',
+  'CURRENT_DATE',
+  'CURRENT_ROLE',
+  'CURRENT_TIME',
+  'CURRENT_TIMESTAMP',
+  'CURRENT_USER',
+  'DEFAULT',
+  'DEFERRABLE',
+  'DESC',
+  'DISTINCT',
+  'DO',
+  'ELSE',
+  'END',
+  'EXCEPT',
+  'FALSE',
+  'FETCH',
+  'FOR',
+  'FOREIGN',
+  'FROM',
+  'GRANT',
+  'GROUP',
+  'HAVING',
+  'IN',
+  'INITIALLY',
+  'INTERSECT',
+  'INTO',
+  'LATERAL',
+  'LEADING',
+  'LIMIT',
+  'LOCALTIME',
+  'LOCALTIMESTAMP',
+  'NOT',
+  'NULL',
+  'OFFSET',
+  'ON',
+  'ONLY',
+  'OR',
+  'ORDER',
+  'PLACING',
+  'PRIMARY',
+  'REFERENCES',
+  'RETURNING',
+  'SELECT',
+  'SESSION_USER',
+  'SOME',
+  'SYMMETRIC',
+  'TABLE',
+  'THEN',
+  'TO',
+  'TRAILING',
+  'TRUE',
+  'UNION',
+  'UNIQUE',
+  'USER',
+  'USING',
+  'VARIADIC',
+  'WHEN',
+  'WHERE',
+  'WINDOW',
+  'WITH',
+];

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

@@ -0,0 +1,19 @@
+import { snakeCaseToCamelCase } from './pgl-utils';
+
+describe('snakeCaseToCamelCase', () => {
+  test('single part', () => {
+    // Arrange & Act
+    const name = snakeCaseToCamelCase('name');
+
+    // Assert
+    expect(name).toBe('name');
+  });
+
+  test('multiple parts', () => {
+    // Arrange & Act
+    const name = snakeCaseToCamelCase('new_name_it_is');
+
+    // Assert
+    expect(name).toBe('newNameItIs');
+  });
+});

package/src/commands/publish-schema-to-db/pg-models/pgl-utils.ts

@@ -0,0 +1,115 @@
+import endent from 'endent';
+import * as fs from 'fs';
+import { JSONPgSmartTags } from 'graphile-utils';
+import * as JSON5 from 'json5';
+import * as path from 'path';
+import {
+  BaseSmartTags,
+  PgColumn,
+  PgFkColumn,
+  PgTable,
+  TableSmartTags,
+} from '../abstractions';
+
+/**
+ * Builds smart tags for FK constraints.
+ * @param columns - Array of FK columns.
+ */
+export function buildFkConstraintSmartTags(
+  columns: PgFkColumn[],
+): { [name: string]: BaseSmartTags } {
+  return columns.reduce((acc, col) => {
+    if (col.fkName) {
+      acc[col.fkName] = {
+        tags: {
+          foreignFieldName: `${col.table.displayName ?? col.table.name}`,
+        },
+      };
+    }
+    return acc;
+  }, {} as { [name: string]: BaseSmartTags });
+}
+
+/**
+ * Builds class (table) level smart tags.
+ * @param tables - Array of tables.
+ */
+export function buildClassSmartTags(
+  tables: PgTable[],
+): { [name: string]: TableSmartTags } {
+  const tags: { [name: string]: TableSmartTags } = {};
+
+  tables.forEach((t) => {
+    tags[t.name] = t.buildSmartTags();
+  });
+
+  return tags;
+}
+
+/**
+ * Builds smart tags for virtual FK columns.
+ * @param virtualFks - Array of virtual FK columns.
+ */
+export function buildVirtualFkSmartTags(virtualFks: PgFkColumn[]): string[] {
+  return virtualFks.map((vfk) => {
+    return `(${vfk.name}) references ${vfk.targetPk.table.name}|@omit many`;
+  });
+}
+
+/**
+ * Builds attribute (column) level smart tags.
+ * @param columns - Array of PgColumns.
+ */
+export function buildAttributeSmartTags(
+  columns: PgColumn[],
+): { [name: string]: BaseSmartTags } {
+  return columns.reduce((acc, col) => {
+    acc[col.name] = col.buildSmartTags();
+    return acc;
+  }, {} as { [name: string]: BaseSmartTags });
+}
+
+// TODO: Replace with camelCase from graphile-build.
+export function snakeCaseToCamelCase(input: string): string {
+  return input
+    .split('_')
+    .reduce(
+      (res, word, i) =>
+        i === 0
+          ? word.toLowerCase()
+          : `${res}${word.charAt(0).toUpperCase()}${word
+              .substr(1)
+              .toLowerCase()}`,
+      '',
+    );
+}
+
+/**
+ * Generates a smart tags plugin file.
+ * @param tags - Smart tags configuration.
+ * @param outPath - Output path where the plugin will be written.
+ */
+export function generateSmartTagsPlugin(
+  tags: JSONPgSmartTags,
+  outPath: string,
+): void {
+  const dirPath = path.dirname(outPath);
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+
+  console.log(`Writing smart tags plugn to to ${outPath}.`);
+
+  const pluginSrc = endent`
+  import { makeJSONPgSmartTagsPlugin } from 'graphile-utils';
+  /**
+  * Smart tags to adjust and enhance the generated GraphQL API.
+  */
+  export const SmartTagsPlugin = makeJSONPgSmartTagsPlugin(${endent.pretty(
+    // Use JSON5 to generate keys without quotes to make the generated code already compatible with prettier.
+    JSON5.stringify(tags, null, 2),
+  )});
+  `;
+
+  fs.writeFileSync(outPath, pluginSrc);
+}

package/src/commands/publish-schema-to-db/pg-models/tables/content-entity-table.ts

@@ -0,0 +1,104 @@
+import { JSONSchema4 } from 'json-schema';
+import {
+  PgColumn,
+  PgFkColumn,
+  PgTable,
+  TableSmartTags,
+} from '../../abstractions';
+import { PublishSchemaToDbOptions } from '../../publish-schema-to-db-options';
+import { PkColumn, PrimitiveColumn } from '../columns';
+import {
+  filterProperties,
+  isPrimitiveProperty,
+  mapToPgType,
+} from '../json-schema-parse-utils';
+import {
+  buildAdditionalTableStatements,
+  buildCreateTable,
+  buildDropTableIfExists,
+  buildFullTableName,
+  buildInsertUpdateGrants,
+  buildSelectDeleteGrants,
+} from '../pg-sql-gen-utils';
+import { buildAttributeSmartTags } from '../pgl-utils';
+
+/**
+ * Table model for storing primitive properties of a root entity (movie, collection etc.).
+ */
+export class ContentEntityTable implements PgTable {
+  name: string;
+  displayName?: string;
+  readonly description?: string;
+  readonly pk: PgColumn;
+  readonly fks: PgFkColumn[] = [];
+  readonly virtualFks: PgFkColumn[] = [];
+  readonly columns: PgColumn[] = [];
+  private options: PublishSchemaToDbOptions;
+
+  /**
+   * Constructor for creating ContentEntityTable.
+   * @param name - Name of the table.
+   * @param schema - Name of the database schema.
+   * @param jsonSchemas - Schemas of primitive properties.
+   */
+  constructor(
+    options: PublishSchemaToDbOptions,
+    name: string,
+    jsonSchemas: { [p: string]: JSONSchema4 },
+    description?: string,
+  ) {
+    this.options = options;
+    this.name = name;
+    this.description = description;
+
+    if (jsonSchemas[options.idKey] === undefined) {
+      throw Error(`Could not find the expected PK property "${options.idKey}"`);
+    }
+
+    // 1. Create the PK.
+    this.pk = new PkColumn(this, mapToPgType(jsonSchemas[options.idKey]));
+
+    // 2. Iterate over (already separated) primitive properties.
+    const excluded = [...options.ignoredProperties, options.idKey];
+    for (const propertyName in filterProperties(jsonSchemas, excluded)) {
+      const schema = jsonSchemas[propertyName] as JSONSchema4;
+
+      if (!isPrimitiveProperty(schema)) {
+        throw new Error(
+          'Non-primitive properties are not supported in content entities',
+        );
+      }
+
+      // 3. Create regular 'data' columns.
+      this.columns.push(
+        new PrimitiveColumn(propertyName, mapToPgType(schema), this, {
+          description: schema.description,
+          indexable: propertyName === 'order_no', // Somewhat stinky but it could also be a part of convention.
+        }),
+      );
+    }
+  }
+  buildFullName(): string {
+    return buildFullTableName(this.name, this.options.dbSchema);
+  }
+
+  buildStatements(): string[] {
+    return [
+      buildDropTableIfExists(this),
+      buildCreateTable(this),
+      ...buildAdditionalTableStatements(this),
+      buildSelectDeleteGrants(this),
+      buildInsertUpdateGrants(this),
+    ];
+  }
+
+  buildSmartTags(): TableSmartTags {
+    return {
+      description: this.description,
+      attribute: buildAttributeSmartTags(this.columns),
+      tags: {
+        omit: 'create,update,delete',
+      },
+    };
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './content-entity-table';
+export * from './object-property-table';
+export * from './relations-table';