@finos/legend-extension-dsl-persistence 0.0.1

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

@@ -0,0 +1,47 @@
+/**
+ * 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 Trigger implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class ManualTrigger extends Trigger implements Hashable {
+  override get hashCode(): string {
+    return hashArray([PERSISTENCE_HASH_STRUCTURE.MANUAL_TRIGGER]);
+  }
+}
+
+export class CronTrigger extends Trigger implements Hashable {
+  minutes!: string;
+  hours!: string;
+  dayOfMonth!: string;
+  month!: string;
+  dayOfWeek!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.CRON_TRIGGER,
+      this.minutes,
+      this.hours,
+      this.dayOfMonth,
+      this.month,
+      this.dayOfWeek,
+    ]);
+  }
+}

package/src/models/protocols/pure/DSLPersistence_PureProtocolProcessorPlugin.ts

@@ -0,0 +1,138 @@
+/**
+ * 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 packageJson from '../../../../package.json';
+
+import { Persistence } from '../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_Persistence';
+import { V1_Persistence } from './v1/model/packageableElements/persistence/V1_DSLPersistence_Persistence';
+import {
+  V1_PERSISTENCE_ELEMENT_PROTOCOL_TYPE,
+  V1_persistenceModelSchema,
+} from './v1/transformation/pureProtocol/V1_DSLPersistence_ProtocolHelper';
+import { V1_buildPersistence } from './v1/transformation/pureGraph/to/V1_PersistenceBuilder';
+import { V1_transformPersistence } from './v1/transformation/pureGraph/from/V1_PersistenceTransformer';
+import {
+  type PackageableElement,
+  PureProtocolProcessorPlugin,
+  V1_ElementBuilder,
+  type V1_ElementProtocolClassifierPathGetter,
+  type V1_ElementProtocolDeserializer,
+  type V1_ElementProtocolSerializer,
+  type V1_ElementTransformer,
+  type V1_GraphBuilderContext,
+  type V1_GraphTransformerContext,
+  type V1_PackageableElement,
+} from '@finos/legend-graph';
+import { assertType, type PlainObject } from '@finos/legend-shared';
+import { deserialize, serialize } from 'serializr';
+
+export const PERSISTENCE_ELEMENT_CLASSIFIER_PATH =
+  'meta::pure::persistence::metamodel::Persistence';
+
+export class DSLPersistence_PureProtocolProcessorPlugin extends PureProtocolProcessorPlugin {
+  constructor() {
+    super(
+      packageJson.extensions.pureProtocolProcessorPlugin,
+      packageJson.version,
+    );
+  }
+
+  override V1_getExtraElementBuilders(): V1_ElementBuilder<V1_PackageableElement>[] {
+    return [
+      new V1_ElementBuilder<V1_Persistence>({
+        elementClassName: 'Persistence',
+        _class: V1_Persistence,
+        firstPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): PackageableElement => {
+          assertType(elementProtocol, V1_Persistence);
+          const element = new Persistence(elementProtocol.name);
+          const path = context.currentSubGraph.buildPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          context.currentSubGraph.setOwnElementInExtension(
+            path,
+            element,
+            Persistence,
+          );
+          return element;
+        },
+        secondPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): void => {
+          assertType(elementProtocol, V1_Persistence);
+          V1_buildPersistence(elementProtocol, context);
+        },
+      }),
+    ];
+  }
+
+  override V1_getExtraElementClassifierPathGetters(): V1_ElementProtocolClassifierPathGetter[] {
+    return [
+      (elementProtocol: V1_PackageableElement): string | undefined => {
+        if (elementProtocol instanceof V1_Persistence) {
+          return PERSISTENCE_ELEMENT_CLASSIFIER_PATH;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementProtocolSerializers(): V1_ElementProtocolSerializer[] {
+    return [
+      (
+        elementProtocol: V1_PackageableElement,
+        plugins: PureProtocolProcessorPlugin[],
+      ): PlainObject<V1_PackageableElement> | undefined => {
+        if (elementProtocol instanceof V1_Persistence) {
+          return serialize(V1_persistenceModelSchema(plugins), elementProtocol);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementProtocolDeserializers(): V1_ElementProtocolDeserializer[] {
+    return [
+      (
+        json: PlainObject<V1_PackageableElement>,
+        plugins: PureProtocolProcessorPlugin[],
+      ): V1_PackageableElement | undefined => {
+        if (json._type === V1_PERSISTENCE_ELEMENT_PROTOCOL_TYPE) {
+          return deserialize(V1_persistenceModelSchema(plugins), json);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementTransformers(): V1_ElementTransformer[] {
+    return [
+      (
+        metamodel: PackageableElement,
+        context: V1_GraphTransformerContext,
+      ): V1_PackageableElement | undefined => {
+        if (metamodel instanceof Persistence) {
+          return V1_transformPersistence(metamodel, context);
+        }
+        return undefined;
+      },
+    ];
+  }
+}

package/src/models/protocols/pure/v1/model/packageableElements/persistence/V1_DSLPersistence_Auditing.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 V1_Auditing implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_NoAuditing extends V1_Auditing implements Hashable {
+  override get hashCode(): string {
+    return hashArray([PERSISTENCE_HASH_STRUCTURE.NO_AUDITING]);
+  }
+}
+
+export class V1_DateTimeAuditing extends V1_Auditing implements Hashable {
+  dateTimeField!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.DATE_TIME_AUDITING,
+      this.dateTimeField,
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/packageableElements/persistence/V1_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 V1_DeduplicationStrategy implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_NoDeduplicationStrategy
+  extends V1_DeduplicationStrategy
+  implements Hashable
+{
+  override get hashCode(): string {
+    return hashArray([PERSISTENCE_HASH_STRUCTURE.NO_DEDUPLICATION_STRATEGY]);
+  }
+}
+
+export class V1_AnyVersionDeduplicationStrategy
+  extends V1_DeduplicationStrategy
+  implements Hashable
+{
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.ANY_VERSION_DEDUPLICATION_STRATEGY,
+    ]);
+  }
+}
+
+export class V1_MaxVersionDeduplicationStrategy
+  extends V1_DeduplicationStrategy
+  implements Hashable
+{
+  versionField!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.MAX_VERSION_DEDUPLICATION_STRATEGY,
+      this.versionField,
+    ]);
+  }
+}
+
+export class V1_DuplicateCountDeduplicationStrategy
+  extends V1_DeduplicationStrategy
+  implements Hashable
+{
+  duplicateCountName!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.DUPLICATE_COUNT_DEDUPLICATION_STRATEGY,
+      this.duplicateCountName,
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/packageableElements/persistence/V1_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 { V1_Auditing } from './V1_DSLPersistence_Auditing';
+import type { V1_MergeStrategy } from './V1_DSLPersistence_MergeStrategy';
+import type {
+  V1_TransactionMilestoning,
+  V1_ValidityMilestoning,
+} from './V1_DSLPersistence_Milestoning';
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../../DSLPersistence_ModelUtils';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export abstract class V1_IngestMode implements Hashable {
+  abstract get hashCode(): string;
+}
+
+// snapshot
+
+export class V1_NontemporalSnapshot extends V1_IngestMode implements Hashable {
+  auditing!: V1_Auditing;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.NONTEMPORAL_SNAPSHOT,
+      this.auditing,
+    ]);
+  }
+}
+
+export class V1_UnitemporalSnapshot extends V1_IngestMode implements Hashable {
+  transactionMilestoning!: V1_TransactionMilestoning;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.UNITEMPORAL_SNAPSHOT,
+      this.transactionMilestoning,
+    ]);
+  }
+}
+
+export class V1_BitemporalSnapshot extends V1_IngestMode implements Hashable {
+  transactionMilestoning!: V1_TransactionMilestoning;
+  validityMilestoning!: V1_ValidityMilestoning;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.BITEMPORAL_SNAPSHOT,
+      this.transactionMilestoning,
+      this.validityMilestoning,
+    ]);
+  }
+}
+
+// delta
+
+export class V1_NontemporalDelta extends V1_IngestMode implements Hashable {
+  mergeStrategy!: V1_MergeStrategy;
+  auditing!: V1_Auditing;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.NONTEMPORAL_DELTA,
+      this.mergeStrategy,
+      this.auditing,
+    ]);
+  }
+}
+
+export class V1_UnitemporalDelta extends V1_IngestMode implements Hashable {
+  mergeStrategy!: V1_MergeStrategy;
+  transactionMilestoning!: V1_TransactionMilestoning;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.UNITEMPORAL_DELTA,
+      this.mergeStrategy,
+      this.transactionMilestoning,
+    ]);
+  }
+}
+
+export class V1_BitemporalDelta extends V1_IngestMode implements Hashable {
+  mergeStrategy!: V1_MergeStrategy;
+  transactionMilestoning!: V1_TransactionMilestoning;
+  validityMilestoning!: V1_ValidityMilestoning;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.BITEMPORAL_DELTA,
+      this.mergeStrategy,
+      this.transactionMilestoning,
+      this.validityMilestoning,
+    ]);
+  }
+}
+
+// append only
+
+export class V1_AppendOnly extends V1_IngestMode implements Hashable {
+  auditing!: V1_Auditing;
+  filterDuplicates!: boolean;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.APPEND_ONLY,
+      this.auditing,
+      this.filterDuplicates.toString(),
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/packageableElements/persistence/V1_DSLPersistence_MergeStrategy.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 V1_MergeStrategy implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_NoDeletesMergeStrategy
+  extends V1_MergeStrategy
+  implements Hashable
+{
+  override get hashCode(): string {
+    return hashArray([PERSISTENCE_HASH_STRUCTURE.NO_DELETES_MERGE_STRATEGY]);
+  }
+}
+
+export class V1_DeleteIndicatorMergeStrategy
+  extends V1_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/protocols/pure/v1/model/packageableElements/persistence/V1_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 V1_TransactionMilestoning implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_BatchIdTransactionMilestoning
+  extends V1_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 V1_DateTimeTransactionMilestoning
+  extends V1_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 V1_BatchIdAndDateTimeTransactionMilestoning
+  extends V1_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 V1_ValidityMilestoning implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_DateTimeValidityMilestoning
+  extends V1_ValidityMilestoning
+  implements Hashable
+{
+  dateTimeFromName!: string;
+  dateTimeThruName!: string;
+  derivation!: V1_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 V1_ValidityDerivation implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_SourceSpecifiesFromDateTime
+  extends V1_ValidityDerivation
+  implements Hashable
+{
+  sourceDateTimeFromField!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.SOURCE_SPECIFIES_FROM_DATE_TIME,
+      this.sourceDateTimeFromField,
+    ]);
+  }
+}
+
+export class V1_SourceSpecifiesFromAndThruDateTime
+  extends V1_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/protocols/pure/v1/model/packageableElements/persistence/V1_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 V1_Notifier implements Hashable {
+  notifyees: V1_Notifyee[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.NOTIFIER,
+      hashArray(this.notifyees),
+    ]);
+  }
+}
+
+export abstract class V1_Notifyee implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_EmailNotifyee extends V1_Notifyee implements Hashable {
+  address!: string;
+
+  override get hashCode(): string {
+    return hashArray([PERSISTENCE_HASH_STRUCTURE.EMAIL_NOTIFYEE, this.address]);
+  }
+}
+
+export class V1_PagerDutyNotifyee extends V1_Notifyee implements Hashable {
+  url!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.PAGER_DUTY_NOTIFYEE,
+      this.url,
+    ]);
+  }
+}