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

package/src/commands/publish-schema-to-db/pg-models/tables/object-property-table.ts

@@ -0,0 +1,113 @@
+import { JSONSchema4 } from 'json-schema';
+import {
+  PgColumn,
+  PgFkColumn,
+  PgTable,
+  TableSmartTags,
+} from '../../abstractions';
+import { PublishSchemaToDbOptions } from '../../publish-schema-to-db-options';
+import { FkColumn, PkColumn, PrimitiveColumn } from '../columns';
+import { isPrimitiveProperty, mapToPgType } from '../json-schema-parse-utils';
+import {
+  buildAdditionalTableStatements,
+  buildCreateTable,
+  buildDropTableIfExists,
+  buildFullTableName,
+  buildInsertUpdateGrants,
+  buildName,
+  buildSelectDeleteGrants,
+} from '../pg-sql-gen-utils';
+import {
+  buildAttributeSmartTags,
+  buildFkConstraintSmartTags,
+  snakeCaseToCamelCase,
+} from '../pgl-utils';
+
+/**
+ * Table model for storing complex/object properties (licensing, video streams etc.) of a root entity.
+ * It will have a FK relation to the root entity in the database.
+ */
+export class ObjectPropertyTable 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 ObjectPropertyTable.
+   * @param propertyName - Name of the property.
+   * @param schema - DB schema where this table will be created.
+   * @param jsonSchema - JSON schema describing this object property.
+   * @param contentEntityPk - PK of the content entity this object property belongs to.
+   */
+  constructor(
+    options: PublishSchemaToDbOptions,
+    propertyName: string,
+    jsonSchema: JSONSchema4,
+    contentEntityPk: PgColumn,
+  ) {
+    const isArray = jsonSchema.type === 'array';
+    jsonSchema = isArray ? (jsonSchema?.items as JSONSchema4) : jsonSchema;
+    this.options = options;
+    this.name = buildName(contentEntityPk.table.name, propertyName);
+    this.displayName = snakeCaseToCamelCase(propertyName);
+    this.description = jsonSchema.description;
+
+    // 1. Create a synthetic PK for this table.
+    this.pk = new PkColumn(this, 'INTEGER');
+
+    // 2. Iterate over object properties, convert them to column definitions.
+    for (const key in jsonSchema.properties) {
+      if (options.ignoredProperties.includes(key)) {
+        continue;
+      }
+
+      const propSchema = jsonSchema.properties[key] as JSONSchema4;
+
+      if (!isPrimitiveProperty(propSchema)) {
+        throw new TypeError(
+          `Unsupported property in object schema: ${propSchema}`,
+        );
+      }
+
+      this.columns.push(
+        new PrimitiveColumn(key, mapToPgType(propSchema), this, {
+          description: propSchema.description,
+        }),
+      );
+    }
+
+    // 3. Add FK(s).
+    this.fks.push(new FkColumn(contentEntityPk, this));
+  }
+
+  buildFullName(): string {
+    return buildFullTableName(this.name, this.options.dbSchema);
+  }
+
+  buildSmartTags(): TableSmartTags {
+    return {
+      description: this.description,
+      attribute: buildAttributeSmartTags(this.columns),
+      tags: {
+        omitFromQueryRoot: true,
+        omit: 'create,update,delete',
+      },
+      constraint: buildFkConstraintSmartTags(this.fks),
+    };
+  }
+
+  buildStatements(): string[] {
+    return [
+      buildDropTableIfExists(this),
+      buildCreateTable(this),
+      ...buildAdditionalTableStatements(this),
+      buildSelectDeleteGrants(this),
+      buildInsertUpdateGrants(this),
+    ];
+  }
+}

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

@@ -0,0 +1,115 @@
+import {
+  PgColumn,
+  PgFkColumn,
+  PgTable,
+  PgType,
+  TableSmartTags,
+} from '../../abstractions';
+import { PublishSchemaToDbOptions } from '../../publish-schema-to-db-options';
+import {
+  FkColumn,
+  PkColumn,
+  PrimitiveColumn,
+  PrimitiveColumnOptions,
+  VirtualFkColumn,
+} from '../columns';
+import {
+  buildAdditionalTableStatements,
+  buildCreateTable,
+  buildDropTableIfExists,
+  buildFullTableName,
+  buildInsertUpdateGrants,
+  buildName,
+  buildSelectDeleteGrants,
+} from '../pg-sql-gen-utils';
+import {
+  buildFkConstraintSmartTags,
+  buildVirtualFkSmartTags,
+} from '../pgl-utils';
+
+/**
+ * Configuration interface for creating additional columns in the relations table.
+ */
+export interface AdditionalColumnOptions {
+  /** Name of the column. */
+  name: string;
+  /** Type of the column. */
+  type: PgType;
+  /** Additional options. */
+  options?: PrimitiveColumnOptions;
+}
+
+/**
+ * Table model for maintaining arbitrary (soft/virtual) on-to-many relationships.
+ */
+export class RelationsTable 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 RelationsTable.
+   * @param contentEntity - Content entity these relations are attached to.
+   * @param relatedEntities - Array of other content entities to create relations to.
+   * @param schema - DB schema where this table will be created.
+   * @param displayName - Display name of this table, used in the generated GQL API.
+   * @param additionalColumnOptions - Array of configuration objects for constructing additional PrimitiveColumn instances.
+   */
+  constructor(
+    config: PublishSchemaToDbOptions,
+    contentEntity: PgTable,
+    relatedEntities: PgTable[],
+    displayName: string,
+    additionalColumnOptions?: AdditionalColumnOptions[],
+    description?: string,
+  ) {
+    this.options = config;
+    this.displayName = displayName;
+    this.name = buildName(contentEntity.pk.table.name, displayName, 'relation');
+    this.description = description;
+    this.pk = new PkColumn(this, 'INTEGER');
+    this.fks.push(new FkColumn(contentEntity.pk, this));
+    if (additionalColumnOptions) {
+      this.columns.push(
+        ...additionalColumnOptions.map(
+          (o) => new PrimitiveColumn(o.name, o.type, this, o.options),
+        ),
+      );
+    }
+
+    for (const relatedEntity of relatedEntities) {
+      this.virtualFks.push(new VirtualFkColumn(relatedEntity.pk, this));
+    }
+  }
+
+  buildFullName(): string {
+    return buildFullTableName(this.name, this.options.dbSchema);
+  }
+
+  buildSmartTags(): TableSmartTags {
+    return {
+      description: this.description,
+      tags: {
+        omitFromQueryRoot: true,
+        omit: 'create,update,delete',
+        foreignKey: buildVirtualFkSmartTags(this.virtualFks),
+      },
+      constraint: buildFkConstraintSmartTags(this.fks),
+    };
+  }
+
+  buildStatements(): string[] {
+    return [
+      buildDropTableIfExists(this),
+      buildCreateTable(this),
+      ...buildAdditionalTableStatements(this),
+      buildSelectDeleteGrants(this),
+      buildInsertUpdateGrants(this),
+    ];
+  }
+}

package/src/commands/publish-schema-to-db/postprocessors/collection-postprocessor.ts

@@ -0,0 +1,33 @@
+import { RelationsTable } from '../pg-models/tables';
+import { ContentEntityModelPostprocessor } from './content-entity-model-postprocessor';
+import { findEntityModel } from './postprocessing-utils';
+
+export const collectionPostprocessor: ContentEntityModelPostprocessor = (
+  mainModel,
+  otherModels,
+  options,
+) => {
+  const relatedItemModels = ['movie', 'tvshow', 'season', 'episode'].map((n) =>
+    findEntityModel(otherModels, n),
+  );
+
+  mainModel.relatedObjects.push(
+    new RelationsTable(
+      options,
+      mainModel.contentEntity,
+      relatedItemModels.map((m) => m.contentEntity),
+      'items',
+      [
+        {
+          name: 'order_no',
+          type: 'INTEGER',
+          options: { extraParams: 'NOT NULL DEFAULT 0', indexable: true },
+        },
+        {
+          name: 'relation_type',
+          type: 'TEXT',
+        },
+      ],
+    ),
+  );
+};

package/src/commands/publish-schema-to-db/postprocessors/content-entity-model-postprocessor.ts

@@ -0,0 +1,13 @@
+import { ContentEntityModel } from '../content-entity-model';
+import { PublishSchemaToDbOptions } from '../publish-schema-to-db-options';
+
+/**
+ * Post processes a ContentEntityModel instance. Useful for implementing custom logic for different content types.
+ */
+export interface ContentEntityModelPostprocessor {
+  (
+    mainModel: ContentEntityModel,
+    otherModels: ContentEntityModel[],
+    options: PublishSchemaToDbOptions,
+  ): void;
+}

package/src/commands/publish-schema-to-db/postprocessors/episode-postprocessor.ts

@@ -0,0 +1,37 @@
+import { VirtualFkColumn } from '../pg-models/columns';
+import { applyNameOverrides } from '../pg-models/pg-sql-gen-utils';
+import { RelationsTable } from '../pg-models/tables';
+import { ContentEntityModelPostprocessor } from './content-entity-model-postprocessor';
+import { findEntityModel, removeColumnByName } from './postprocessing-utils';
+
+export const episodePostprocessor: ContentEntityModelPostprocessor = (
+  mainModel,
+  otherModels,
+  options,
+) => {
+  const seasonModel = findEntityModel(otherModels, 'season');
+  const tvshowGenreModel = findEntityModel(otherModels, 'tvshow_genre');
+  applyNameOverrides(mainModel, {
+    cast: ['episode_cast', 'cast'],
+  });
+  removeColumnByName(mainModel.contentEntity.columns, 'season_id');
+  mainModel.contentEntity.virtualFks.push(
+    new VirtualFkColumn(seasonModel.contentEntity.pk, mainModel.contentEntity),
+  );
+
+  mainModel.relatedObjects.push(
+    new RelationsTable(
+      options,
+      mainModel.contentEntity,
+      [tvshowGenreModel.contentEntity],
+      'genres',
+      [
+        {
+          name: 'order_no',
+          type: 'INTEGER',
+          options: { extraParams: 'NOT NULL DEFAULT 0', indexable: true },
+        },
+      ],
+    ),
+  );
+};

package/src/commands/publish-schema-to-db/postprocessors/index.ts

@@ -0,0 +1,6 @@
+export * from './collection-postprocessor';
+export * from './content-entity-model-postprocessor';
+export * from './episode-postprocessor';
+export * from './movie-postprocessor';
+export * from './season-postprocessor';
+export * from './tvshow-postprocessor';

package/src/commands/publish-schema-to-db/postprocessors/movie-postprocessor.ts

@@ -0,0 +1,30 @@
+import { applyNameOverrides } from '../pg-models/pg-sql-gen-utils';
+import { RelationsTable } from '../pg-models/tables';
+import { ContentEntityModelPostprocessor } from './content-entity-model-postprocessor';
+import { findEntityModel } from './postprocessing-utils';
+
+export const moviePostprocessor: ContentEntityModelPostprocessor = (
+  mainModel,
+  otherModels,
+  options,
+) => {
+  const movieGenreModel = findEntityModel(otherModels, 'movie_genre');
+  applyNameOverrides(mainModel, {
+    cast: ['movie_cast', 'cast'],
+  });
+  mainModel.relatedObjects.push(
+    new RelationsTable(
+      options,
+      mainModel.contentEntity,
+      [movieGenreModel.contentEntity],
+      'genres',
+      [
+        {
+          name: 'order_no',
+          type: 'INTEGER',
+          options: { extraParams: 'NOT NULL DEFAULT 0', indexable: true },
+        },
+      ],
+    ),
+  );
+};

package/src/commands/publish-schema-to-db/postprocessors/postprocessing-utils.ts

@@ -0,0 +1,21 @@
+import { PgColumn } from '../abstractions';
+import { ContentEntityModel } from '../content-entity-model';
+
+export function findEntityModel(
+  models: ContentEntityModel[],
+  entityName: string,
+): ContentEntityModel {
+  const entityModel = models.find((m) => m.contentEntity.name === entityName);
+  if (!entityModel) {
+    throw Error(`Content entity model for ${entityName} not found.`);
+  }
+  return entityModel;
+}
+
+export function removeColumnByName(columns: PgColumn[], name: string): void {
+  columns.forEach((c, i) => {
+    if (c.name === name) {
+      columns.splice(i, 1);
+    }
+  });
+}

package/src/commands/publish-schema-to-db/postprocessors/season-postprocessor.ts

@@ -0,0 +1,37 @@
+import { VirtualFkColumn } from '../pg-models/columns';
+import { applyNameOverrides } from '../pg-models/pg-sql-gen-utils';
+import { RelationsTable } from '../pg-models/tables';
+import { ContentEntityModelPostprocessor } from './content-entity-model-postprocessor';
+import { findEntityModel, removeColumnByName } from './postprocessing-utils';
+
+export const seasonPostprocessor: ContentEntityModelPostprocessor = (
+  mainModel,
+  otherModels,
+  options,
+) => {
+  const tvshowModel = findEntityModel(otherModels, 'tvshow');
+  const tvshowGenreModel = findEntityModel(otherModels, 'tvshow_genre');
+  applyNameOverrides(mainModel, {
+    cast: ['season_cast', 'cast'],
+  });
+  removeColumnByName(mainModel.contentEntity.columns, 'tvshow_id');
+  mainModel.contentEntity.virtualFks.push(
+    new VirtualFkColumn(tvshowModel.contentEntity.pk, mainModel.contentEntity),
+  );
+
+  mainModel.relatedObjects.push(
+    new RelationsTable(
+      options,
+      mainModel.contentEntity,
+      [tvshowGenreModel.contentEntity],
+      'genres',
+      [
+        {
+          name: 'order_no',
+          type: 'INTEGER',
+          options: { extraParams: 'NOT NULL DEFAULT 0', indexable: true },
+        },
+      ],
+    ),
+  );
+};

package/src/commands/publish-schema-to-db/postprocessors/tvshow-postprocessor.ts

@@ -0,0 +1,30 @@
+import { applyNameOverrides } from '../pg-models/pg-sql-gen-utils';
+import { RelationsTable } from '../pg-models/tables';
+import { ContentEntityModelPostprocessor } from './content-entity-model-postprocessor';
+import { findEntityModel } from './postprocessing-utils';
+
+export const tvshowPostprocessor: ContentEntityModelPostprocessor = (
+  mainModel,
+  otherModels,
+  options,
+) => {
+  const tvshowGenreModel = findEntityModel(otherModels, 'tvshow_genre');
+  applyNameOverrides(mainModel, {
+    cast: ['tvshow_cast', 'cast'],
+  });
+  mainModel.relatedObjects.push(
+    new RelationsTable(
+      options,
+      mainModel.contentEntity,
+      [tvshowGenreModel.contentEntity],
+      'genres',
+      [
+        {
+          name: 'order_no',
+          type: 'INTEGER',
+          options: { extraParams: 'NOT NULL DEFAULT 0', indexable: true },
+        },
+      ],
+    ),
+  );
+};

package/src/commands/publish-schema-to-db/publish-schema-to-db-options.ts

@@ -0,0 +1,15 @@
+/**
+ * CLI command options.
+ */
+export interface PublishSchemaToDbOptions {
+  /** Input glob pattern that selects input schemas. */
+  inputGlob: string;
+  /** Name of the ID key in JSON schema. */
+  idKey: string;
+  /** Array of ignored JSON schema properties. */
+  ignoredProperties: string[];
+  /** Name of the DB schema to be used in SQL generation. */
+  dbSchema: string;
+  /** Path to the target project root. */
+  outputRoot: string;
+}

package/src/commands/publish-schema-to-db/types/sql-formatter.d.ts

@@ -0,0 +1,10 @@
+declare module 'sql-formatter' {
+  export function format(
+    query: string,
+    cfg?: {
+      language?: string;
+      indent?: string;
+      params?: { [x: string]: string } | string[];
+    },
+  ): string;
+}

package/src/exports.ts

@@ -0,0 +1,2 @@
+export * from './commands/get-access-token/get-access-token-options';
+export * from './commands/get-access-token/get-dev-access-token';

package/src/index.ts

@@ -0,0 +1 @@
+export { run } from './cli';