@finos/legend-extension-dsl-persistence 0.0.1

package/src/models/metamodels/pure/model/packageableElements/persistence/DSLPersistence_DeduplicationStrategy.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../DSLPersistence_ModelUtils';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export abstract class DeduplicationStrategy implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class NoDeduplicationStrategy
+  extends DeduplicationStrategy
+  implements Hashable
+{
+  override get hashCode(): string {
+    return hashArray([PERSISTENCE_HASH_STRUCTURE.NO_DEDUPLICATION_STRATEGY]);
+  }
+}
+
+export class AnyVersionDeduplicationStrategy
+  extends DeduplicationStrategy
+  implements Hashable
+{
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.ANY_VERSION_DEDUPLICATION_STRATEGY,
+    ]);
+  }
+}
+
+export class MaxVersionDeduplicationStrategy
+  extends DeduplicationStrategy
+  implements Hashable
+{
+  versionField!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.MAX_VERSION_DEDUPLICATION_STRATEGY,
+      this.versionField,
+    ]);
+  }
+}
+
+export class DuplicateCountDeduplicationStrategy
+  extends DeduplicationStrategy
+  implements Hashable
+{
+  duplicateCountName!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.DUPLICATE_COUNT_DEDUPLICATION_STRATEGY,
+      this.duplicateCountName,
+    ]);
+  }
+}

package/src/models/metamodels/pure/model/packageableElements/persistence/DSLPersistence_IngestMode.ts

@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { Auditing } from './DSLPersistence_Auditing';
+import type { MergeStrategy } from './DSLPersistence_MergeStrategy';
+import type {
+  TransactionMilestoning,
+  ValidityMilestoning,
+} from './DSLPersistence_Milestoning';
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../DSLPersistence_ModelUtils';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export abstract class IngestMode implements Hashable {
+  abstract get hashCode(): string;
+}
+
+// snapshot
+
+export class NontemporalSnapshot extends IngestMode implements Hashable {
+  auditing!: Auditing;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.NONTEMPORAL_SNAPSHOT,
+      this.auditing,
+    ]);
+  }
+}
+
+export class UnitemporalSnapshot extends IngestMode implements Hashable {
+  transactionMilestoning!: TransactionMilestoning;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.UNITEMPORAL_SNAPSHOT,
+      this.transactionMilestoning,
+    ]);
+  }
+}
+
+export class BitemporalSnapshot extends IngestMode implements Hashable {
+  transactionMilestoning!: TransactionMilestoning;
+  validityMilestoning!: ValidityMilestoning;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.BITEMPORAL_SNAPSHOT,
+      this.transactionMilestoning,
+      this.validityMilestoning,
+    ]);
+  }
+}
+
+// delta
+
+export class NontemporalDelta extends IngestMode implements Hashable {
+  mergeStrategy!: MergeStrategy;
+  auditing!: Auditing;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.NONTEMPORAL_DELTA,
+      this.mergeStrategy,
+      this.auditing,
+    ]);
+  }
+}
+
+export class UnitemporalDelta extends IngestMode implements Hashable {
+  mergeStrategy!: MergeStrategy;
+  transactionMilestoning!: TransactionMilestoning;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.UNITEMPORAL_DELTA,
+      this.mergeStrategy,
+      this.transactionMilestoning,
+    ]);
+  }
+}
+
+export class BitemporalDelta extends IngestMode implements Hashable {
+  mergeStrategy!: MergeStrategy;
+  transactionMilestoning!: TransactionMilestoning;
+  validityMilestoning!: ValidityMilestoning;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.BITEMPORAL_DELTA,
+      this.mergeStrategy,
+      this.transactionMilestoning,
+      this.validityMilestoning,
+    ]);
+  }
+}
+
+// append only
+
+export class AppendOnly extends IngestMode implements Hashable {
+  auditing!: Auditing;
+  filterDuplicates!: boolean;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.APPEND_ONLY,
+      this.auditing,
+      this.filterDuplicates.toString(),
+    ]);
+  }
+}

package/src/models/metamodels/pure/model/packageableElements/persistence/DSLPersistence_MergeStrategy.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../DSLPersistence_ModelUtils';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export abstract class MergeStrategy implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class NoDeletesMergeStrategy extends MergeStrategy implements Hashable {
+  override get hashCode(): string {
+    return hashArray([PERSISTENCE_HASH_STRUCTURE.NO_DELETES_MERGE_STRATEGY]);
+  }
+}
+
+export class DeleteIndicatorMergeStrategy
+  extends MergeStrategy
+  implements Hashable
+{
+  deleteField!: string;
+  deleteValues: string[] = [];
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.DELETE_INDICATOR_MERGE_STRATEGY,
+      this.deleteField,
+      hashArray(this.deleteValues),
+    ]);
+  }
+}

package/src/models/metamodels/pure/model/packageableElements/persistence/DSLPersistence_Milestoning.ts

@@ -0,0 +1,136 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../DSLPersistence_ModelUtils';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+// transaction milestoning
+
+export abstract class TransactionMilestoning implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class BatchIdTransactionMilestoning
+  extends TransactionMilestoning
+  implements Hashable
+{
+  batchIdInName!: string;
+  batchIdOutName!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.BATCH_ID_TRANSACTION_MILESTONING,
+      this.batchIdInName,
+      this.batchIdOutName,
+    ]);
+  }
+}
+
+export class DateTimeTransactionMilestoning
+  extends TransactionMilestoning
+  implements Hashable
+{
+  dateTimeInName!: string;
+  dateTimeOutName!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.DATE_TIME_TRANSACTION_MILESTONING,
+      this.dateTimeInName,
+      this.dateTimeOutName,
+    ]);
+  }
+}
+
+export class BatchIdAndDateTimeTransactionMilestoning
+  extends TransactionMilestoning
+  implements Hashable
+{
+  batchIdInName!: string;
+  batchIdOutName!: string;
+  dateTimeInName!: string;
+  dateTimeOutName!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.BATCH_ID_AND_DATE_TIME_TRANSACTION_MILESTONING,
+      this.batchIdInName,
+      this.batchIdOutName,
+      this.dateTimeInName,
+      this.dateTimeOutName,
+    ]);
+  }
+}
+
+// validity milestoning
+
+export abstract class ValidityMilestoning implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class DateTimeValidityMilestoning
+  extends ValidityMilestoning
+  implements Hashable
+{
+  dateTimeFromName!: string;
+  dateTimeThruName!: string;
+  derivation!: ValidityDerivation;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.DATE_TIME_VALIDITY_MILESTONING,
+      this.dateTimeFromName,
+      this.dateTimeThruName,
+      this.derivation,
+    ]);
+  }
+}
+
+// validity derivation
+
+export abstract class ValidityDerivation implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class SourceSpecifiesFromDateTime
+  extends ValidityDerivation
+  implements Hashable
+{
+  sourceDateTimeFromField!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.SOURCE_SPECIFIES_FROM_DATE_TIME,
+      this.sourceDateTimeFromField,
+    ]);
+  }
+}
+
+export class SourceSpecifiesFromAndThruDateTime
+  extends ValidityDerivation
+  implements Hashable
+{
+  sourceDateTimeFromField!: string;
+  sourceDateTimeThruField!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.SOURCE_SPECIFIES_FROM_AND_THRU_DATE_TIME,
+      this.sourceDateTimeFromField,
+      this.sourceDateTimeThruField,
+    ]);
+  }
+}

package/src/models/metamodels/pure/model/packageableElements/persistence/DSLPersistence_Notifier.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../DSLPersistence_ModelUtils';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export class Notifier implements Hashable {
+  notifyees: Notifyee[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.NOTIFIER,
+      hashArray(this.notifyees),
+    ]);
+  }
+}
+
+export abstract class Notifyee implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class EmailNotifyee extends Notifyee implements Hashable {
+  address!: string;
+
+  override get hashCode(): string {
+    return hashArray([PERSISTENCE_HASH_STRUCTURE.EMAIL_NOTIFYEE, this.address]);
+  }
+}
+
+export class PagerDutyNotifyee extends Notifyee implements Hashable {
+  url!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.PAGER_DUTY_NOTIFYEE,
+      this.url,
+    ]);
+  }
+}

package/src/models/metamodels/pure/model/packageableElements/persistence/DSLPersistence_Persistence.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { Notifier } from './DSLPersistence_Notifier';
+import type { Persister } from './DSLPersistence_Persister';
+import type { Trigger } from './DSLPersistence_Trigger';
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../DSLPersistence_ModelUtils';
+import {
+  PackageableElement,
+  type PackageableElementReference,
+  type PackageableElementVisitor,
+  type Service,
+} from '@finos/legend-graph';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export class Persistence extends PackageableElement implements Hashable {
+  documentation!: string;
+  trigger!: Trigger;
+  service!: PackageableElementReference<Service>;
+  persister!: Persister;
+  notifier!: Notifier;
+
+  protected override get _elementHashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.PERSISTENCE,
+      this.documentation,
+      this.trigger,
+      this.service.hashValue,
+      this.persister,
+      this.notifier,
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_PackageableElement(this);
+  }
+}

package/src/models/metamodels/pure/model/packageableElements/persistence/DSLPersistence_Persister.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { IngestMode } from './DSLPersistence_IngestMode';
+import type { Sink } from './DSLPersistence_Sink';
+import type { TargetShape } from './DSLPersistence_TargetShape';
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../DSLPersistence_ModelUtils';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export abstract class Persister implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class StreamingPersister extends Persister implements Hashable {
+  sink!: Sink;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.STREAMING_PERSISTER,
+      this.sink,
+    ]);
+  }
+}
+
+export class BatchPersister extends Persister implements Hashable {
+  sink!: Sink;
+  ingestMode!: IngestMode;
+  targetShape!: TargetShape;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.BATCH_PERSISTER,
+      this.sink,
+      this.ingestMode,
+      this.targetShape,
+    ]);
+  }
+}

package/src/models/metamodels/pure/model/packageableElements/persistence/DSLPersistence_Sink.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../DSLPersistence_ModelUtils';
+import type {
+  Binding,
+  Connection,
+  PackageableElementReference,
+} from '@finos/legend-graph';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export abstract class Sink implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class RelationalSink extends Sink implements Hashable {
+  connection?: Connection;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.RELATIONAL_SINK,
+      this.connection ?? '',
+    ]);
+  }
+}
+
+export class ObjectStorageSink extends Sink implements Hashable {
+  binding!: PackageableElementReference<Binding>;
+  connection!: Connection;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.OBJECT_STORAGE_SINK,
+      this.binding.hashValue,
+      this.connection,
+    ]);
+  }
+}

package/src/models/metamodels/pure/model/packageableElements/persistence/DSLPersistence_TargetShape.ts

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { DeduplicationStrategy } from './DSLPersistence_DeduplicationStrategy';
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../DSLPersistence_ModelUtils';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import type { Class, PackageableElementReference } from '@finos/legend-graph';
+
+export abstract class TargetShape implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class FlatTarget extends TargetShape implements Hashable {
+  modelClass?: PackageableElementReference<Class>;
+  targetName!: string;
+  partitionFields: string[] = [];
+  deduplicationStrategy!: DeduplicationStrategy;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.FLAT_TARGET,
+      this.modelClass?.hashValue ?? '',
+      this.targetName,
+      hashArray(this.partitionFields),
+      this.deduplicationStrategy,
+    ]);
+  }
+}
+
+export class MultiFlatTarget extends TargetShape implements Hashable {
+  modelClass!: PackageableElementReference<Class>;
+  transactionScope!: TransactionScope;
+  parts: MultiFlatTargetPart[] = [];
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.MULTI_FLAT_TARGET,
+      this.modelClass.hashValue,
+      this.transactionScope,
+      hashArray(this.parts),
+    ]);
+  }
+}
+
+export class MultiFlatTargetPart implements Hashable {
+  modelProperty!: string;
+  targetName!: string;
+  partitionFields: string[] = [];
+  deduplicationStrategy!: DeduplicationStrategy;
+
+  get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.MULTI_FLAT_TARGET_PART,
+      this.modelProperty,
+      this.targetName,
+      hashArray(this.partitionFields),
+      this.deduplicationStrategy,
+    ]);
+  }
+}
+
+export enum TransactionScope {
+  SINGLE_TARGET = 'SINGLE_TARGET',
+  ALL_TARGETS = 'ALL_TARGETS',
+}