@powersync/service-core 1.21.0 → 1.23.0

package/src/storage/BucketStorageFactory.ts

@@ -2,13 +2,15 @@ import { BaseObserver, logger } from '@powersync/lib-services-framework';
 import {
   PrecompiledSyncConfig,
   SerializedCompatibilityContext,
+  SerializedSyncPlanV1,
   serializeSyncPlan,
   SqlSyncRules,
   SyncConfigWithErrors
 } from '@powersync/service-sync-rules';
 import { ReplicationError } from '@powersync/service-types';
 import { syncConfigYamlErrorToReplicationError } from '../util/errors.js';
-import { ParseSyncRulesOptions, PersistedSyncRules, PersistedSyncRulesContent } from './PersistedSyncRulesContent.js';
+import { PersistedReplicationStream } from './PersistedReplicationStream.js';
+import { PersistedSyncConfigContent } from './PersistedSyncConfigContent.js';
 import { ReplicationEventPayload } from './ReplicationEventPayload.js';
 import { ReplicationLock } from './ReplicationLock.js';
 import { ReportStorage } from './ReportStorage.js';
@@ -31,14 +33,14 @@ export abstract class BucketStorageFactory
    */
   async configureSyncRules(
     options: UpdateSyncRulesOptions
-  ): Promise<{ updated: boolean; persisted_sync_rules?: PersistedSyncRulesContent; lock?: ReplicationLock }> {
-    const next = await this.getNextSyncRulesContent();
-    const active = await this.getActiveSyncRulesContent();
+  ): Promise<{ updated: boolean; persisted_sync_rules?: PersistedReplicationStream; lock?: ReplicationLock }> {
+    const deploying = await this.getDeployingSyncConfig();
+    const active = await this.getActiveSyncConfig();
 
-    if (next?.sync_rules_content == options.config.yaml) {
+    if (deploying?.content.sync_rules_content == options.config.yaml) {
       logger.info('Sync config unchanged');
       return { updated: false };
-    } else if (next == null && active?.sync_rules_content == options.config.yaml) {
+    } else if (deploying == null && active?.content.sync_rules_content == options.config.yaml) {
       logger.info('Sync config unchanged');
       return { updated: false };
     } else {
@@ -51,12 +53,15 @@ export abstract class BucketStorageFactory
   /**
    * Get a storage instance to query sync data for specific sync config.
    */
-  abstract getInstance(syncRules: PersistedSyncRulesContent, options?: GetIntanceOptions): SyncRulesBucketStorage;
+  abstract getInstance(
+    replicationStream: PersistedReplicationStream,
+    options?: GetIntanceOptions
+  ): SyncRulesBucketStorage;
 
   /**
    * Deploy new sync config.
    */
-  abstract updateSyncRules(options: UpdateSyncRulesOptions): Promise<PersistedSyncRulesContent>;
+  abstract updateSyncRules(options: UpdateSyncRulesOptions): Promise<PersistedReplicationStream>;
 
   /**
    * Indicate that a slot was removed, and we should re-sync by creating
@@ -68,48 +73,27 @@ export abstract class BucketStorageFactory
    *
    * Replication should be restarted after this.
    */
-  abstract restartReplication(sync_rules_group_id: number): Promise<void>;
+  abstract restartReplication(replicationStreamId: number): Promise<void>;
 
   /**
-   * Get the sync config used for querying.
+   * Get the sync config and storage used for querying.
    */
-  async getActiveSyncRules(options: ParseSyncRulesOptions): Promise<PersistedSyncRules | null> {
-    const content = await this.getActiveSyncRulesContent();
-    return content?.parsed(options) ?? null;
-  }
-
-  /**
-   * Get the sync config used for querying.
-   */
-  abstract getActiveSyncRulesContent(): Promise<PersistedSyncRulesContent | null>;
-
-  /**
-   * Get the sync config that will be active next once done with initial replicatino.
-   */
-  async getNextSyncRules(options: ParseSyncRulesOptions): Promise<PersistedSyncRules | null> {
-    const content = await this.getNextSyncRulesContent();
-    return content?.parsed(options) ?? null;
-  }
+  abstract getActiveSyncConfig(): Promise<ResolvedSyncConfig | null>;
 
   /**
-   * Get the sync config that will be active next once done with initial replicatino.
+   * Get the sync config and storage that is still deploying.
    */
-  abstract getNextSyncRulesContent(): Promise<PersistedSyncRulesContent | null>;
+  abstract getDeployingSyncConfig(): Promise<ResolvedSyncConfig | null>;
 
   /**
-   * Get all sync config currently replicating. Typically this is the "active" and "next" sync config.
+   * Get all replication streams currently replicating.
    */
-  abstract getReplicatingSyncRules(): Promise<PersistedSyncRulesContent[]>;
+  abstract getReplicatingReplicationStreams(): Promise<PersistedReplicationStream[]>;
 
   /**
-   * Get all sync config stopped but not terminated yet.
+   * Get all replication streams stopped but not terminated yet.
    */
-  abstract getStoppedSyncRules(): Promise<PersistedSyncRulesContent[]>;
-
-  /**
-   * Get the active storage instance.
-   */
-  abstract getActiveStorage(): Promise<SyncRulesBucketStorage | null>;
+  abstract getStoppedReplicationStreams(): Promise<PersistedReplicationStream[]>;
 
   /**
    * Get storage size of active replication stream.
@@ -134,6 +118,12 @@ export interface BucketStorageFactoryListener {
   replicationEvent: (event: ReplicationEventPayload) => void;
 }
 
+export interface ResolvedSyncConfig {
+  content: PersistedSyncConfigContent;
+  replicationStream: PersistedReplicationStream;
+  storage: SyncRulesBucketStorage;
+}
+
 export interface StorageMetrics {
   /**
    * Size of operations (bucket_data)
@@ -170,13 +160,18 @@ export interface UpdateSyncRulesOptions {
   };
   lock?: boolean;
   storageVersion?: number;
+
+  /**
+   * Only relevant if the result is used. This does not affect the persisted config.
+   */
+  defaultSchema?: string;
 }
 
 export interface SerializedSyncPlan {
   /**
    * The serialized plan, from {@link serializeSyncPlan}.
    */
-  plan: unknown;
+  plan: SerializedSyncPlanV1;
   compatibility: SerializedCompatibilityContext;
   /**
    * Event descriptors are not currently represented in the sync plan because they don't use the sync streams compiler
@@ -196,7 +191,7 @@ export function updateSyncRulesFromYaml(
   const config = SqlSyncRules.fromYaml(content, {
     // No schema-based validation at this point
     schema: undefined,
-    defaultSchema: 'not_applicable', // Not needed for validation
+    defaultSchema: options?.defaultSchema ?? 'not_applicable', // Not needed for validation
     throwOnError: options?.validate ?? false
   });
 
@@ -273,4 +268,5 @@ export interface TestStorageConfig {
   factory: TestStorageFactory;
   tableIdStrings: boolean;
   storageVersion?: number;
+  compressedBucketStorage?: boolean;
 }

package/src/storage/ParsedSyncConfigSet.ts

@@ -0,0 +1,25 @@
+import { HydratedSyncConfig, HydrationState, SyncConfigWithErrors } from '@powersync/service-sync-rules';
+
+/**
+ * A parsed sync config set is the identity boundary for parsed sync config state.
+ *
+ * All values on a single instance - the parsed configs, hydration state and hydrated
+ * sync config - are derived from the same parse, and may be associated with each other
+ * by object identity. Values from two different instances must never be mixed, even if
+ * they were parsed from the same persisted content.
+ */
+export interface ParsedSyncConfigSet {
+  readonly replicationStreamId: number;
+  readonly replicationStreamName: string;
+  readonly syncConfigs: SyncConfigWithErrors[];
+  /**
+   * For testing only.
+   */
+  readonly hydrationState: HydrationState;
+
+  /**
+   * The hydrated sync config for this parse. This is a stable property: repeated reads
+   * return the same instance.
+   */
+  readonly hydratedSyncConfig: HydratedSyncConfig;
+}

package/src/storage/PersistedReplicationStream.ts

@@ -0,0 +1,55 @@
+import { logger as defaultLogger, ErrorCode, ServiceError } from '@powersync/lib-services-framework';
+import { Logger } from 'winston';
+import { SyncRuleState } from './BucketStorage.js';
+import type { ParsedSyncConfigSet } from './ParsedSyncConfigSet.js';
+import type { ParseSyncConfigOptions, PersistedSyncConfigContent } from './PersistedSyncConfigContent.js';
+import { ReplicationLock } from './ReplicationLock.js';
+import { STORAGE_VERSION_CONFIG, StorageVersionConfig } from './StorageVersionConfig.js';
+
+export abstract class PersistedReplicationStream implements PersistedReplicationStreamData {
+  readonly replicationStreamId: number;
+  readonly replicationJobId: string;
+  readonly replicationStreamName: string;
+  readonly state: SyncRuleState;
+  readonly storageVersion: number;
+  readonly logger: Logger;
+
+  abstract readonly syncConfigContent: readonly PersistedSyncConfigContent[];
+  abstract readonly current_lock: ReplicationLock | null;
+
+  constructor(data: PersistedReplicationStreamData) {
+    this.replicationStreamId = data.replicationStreamId;
+    this.replicationJobId = data.replicationJobId ?? String(data.replicationStreamId);
+    this.replicationStreamName = data.replicationStreamName;
+    this.state = data.state;
+    this.storageVersion = data.storageVersion;
+    this.logger = defaultLogger.child({ prefix: `[${this.replicationStreamName}] ` });
+  }
+
+  getStorageConfig(): StorageVersionConfig {
+    const storageConfig = STORAGE_VERSION_CONFIG[this.storageVersion];
+    if (storageConfig == null) {
+      throw new ServiceError(
+        ErrorCode.PSYNC_S1005,
+        `Unsupported storage version ${this.storageVersion} for replication stream ${this.replicationStreamId}`
+      );
+    }
+    return storageConfig;
+  }
+
+  abstract lock(): Promise<ReplicationLock>;
+
+  abstract parsed(options: ParseSyncConfigOptions): ParsedSyncConfigSet;
+}
+export interface PersistedReplicationStreamData {
+  readonly replicationStreamId: number;
+  readonly replicationStreamName: string;
+  readonly state: SyncRuleState;
+  readonly storageVersion: number;
+  /**
+   * Uniquely identifies a job, as a combination of replication stream and processing sync configs.
+   *
+   * Used in-memory only.
+   */
+  readonly replicationJobId?: string;
+}

package/src/storage/PersistedSyncConfigContent.ts

@@ -0,0 +1,188 @@
+import { logger as defaultLogger, ErrorCode, ServiceError } from '@powersync/lib-services-framework';
+import {
+  CompatibilityContext,
+  CompatibilityOption,
+  DEFAULT_HYDRATION_STATE,
+  deserializeSyncPlan,
+  ErrorLocation,
+  HydratedSyncConfig,
+  HydrationState,
+  nodeSqlite,
+  PrecompiledSyncConfig,
+  SqlEventDescriptor,
+  SqlSyncRules,
+  SyncConfigWithErrors,
+  versionedHydrationState,
+  YamlError
+} from '@powersync/service-sync-rules';
+import * as sqlite from 'node:sqlite';
+import { Logger } from 'winston';
+import { SerializedSyncPlan, UpdateSyncRulesOptions } from './BucketStorageFactory.js';
+import { ParsedSyncConfigSet } from './ParsedSyncConfigSet.js';
+import { PersistedSyncConfigStatus } from './PersistedSyncConfigStatus.js';
+import { STORAGE_VERSION_CONFIG, StorageVersionConfig } from './StorageVersionConfig.js';
+
+export interface ParsePersistedSyncConfigContentOptions {
+  content: string;
+  compiledPlan: SerializedSyncPlan | null;
+  storageVersion: number;
+  parseOptions: ParseSyncConfigOptions;
+}
+
+export function parsePersistedSyncConfigContent(options: ParsePersistedSyncConfigContentOptions): SyncConfigWithErrors {
+  const { content, compiledPlan, storageVersion, parseOptions } = options;
+
+  if (compiledPlan == null) {
+    // Fallback: Only parse from YAML if no compiled plan is available.
+    return SqlSyncRules.fromYaml(content, parseOptions);
+  }
+
+  const plan = deserializeSyncPlan(compiledPlan.plan);
+  const compatibility = CompatibilityContext.deserialize(compiledPlan.compatibility);
+  const eventDefinitions: SqlEventDescriptor[] = [];
+  for (const [name, queries] of Object.entries(compiledPlan.eventDescriptors)) {
+    const descriptor = new SqlEventDescriptor(name, compatibility);
+    for (const query of queries) {
+      descriptor.addSourceQuery(query, parseOptions);
+    }
+
+    eventDefinitions.push(descriptor);
+  }
+
+  const precompiled = new PrecompiledSyncConfig(plan, compatibility, eventDefinitions, {
+    defaultSchema: parseOptions.defaultSchema,
+    sourceText: content
+  });
+
+  // Note: If the original content did not define a storage version, this will still set the storage version.
+  // This means asUpdateOptions will not change the storage version, even if the default changes.
+  precompiled.storageVersion = storageVersion;
+
+  const errors: YamlError[] = [];
+  if (compiledPlan.errors) {
+    for (const error of compiledPlan.errors) {
+      const location: ErrorLocation | undefined = error.location && {
+        start: error.location.start_offset,
+        end: error.location.end_offset
+      };
+      const asYamlError = new YamlError(new Error(error.message), location);
+      asYamlError.type = error.level;
+
+      errors.push(asYamlError);
+    }
+  }
+
+  return { config: precompiled, errors };
+}
+
+/**
+ * Immutable sync config content for one sync config inside a replication stream.
+ *
+ * This represents the persisted config content. Fetch per-config status with
+ * {@link getSyncConfigStatus}. Use {@link PersistedReplicationStream} for stream
+ * lifecycle concerns such as locking and termination.
+ */
+
+export abstract class PersistedSyncConfigContent implements PersistedSyncConfigContentData {
+  readonly replicationStreamId: number;
+  readonly sync_rules_content: string;
+  readonly compiled_plan: SerializedSyncPlan | null;
+  readonly replicationStreamName: string;
+  readonly storageVersion: number;
+  readonly logger: Logger;
+  readonly syncConfigId: PersistedSyncConfigId | null;
+
+  constructor(data: PersistedSyncConfigContentData) {
+    this.replicationStreamId = data.replicationStreamId;
+    this.sync_rules_content = data.sync_rules_content;
+    this.compiled_plan = data.compiled_plan;
+    this.replicationStreamName = data.replicationStreamName;
+    this.storageVersion = data.storageVersion;
+    this.syncConfigId = data.syncConfigId ?? null;
+    this.logger = defaultLogger.child({ prefix: `[${this.replicationStreamName}] ` });
+  }
+
+  /**
+   * Load the storage config.
+   *
+   * This may throw if the persisted storage version is not supported.
+   */
+  getStorageConfig(): StorageVersionConfig {
+    const storageConfig = STORAGE_VERSION_CONFIG[this.storageVersion];
+    if (storageConfig == null) {
+      throw new ServiceError(
+        ErrorCode.PSYNC_S1005,
+        `Unsupported storage version ${this.storageVersion} for replication stream ${this.replicationStreamId}`
+      );
+    }
+    return storageConfig;
+  }
+
+  /**
+   * Parse only this config's content into a single {@link SyncConfigWithErrors}.
+   *
+   * This does not depend on any other configs in the same replication stream.
+   */
+  protected parseSingleConfig(options: ParseSyncConfigOptions): SyncConfigWithErrors {
+    return parsePersistedSyncConfigContent({
+      content: this.sync_rules_content,
+      compiledPlan: this.compiled_plan,
+      storageVersion: this.storageVersion,
+      parseOptions: options
+    });
+  }
+
+  parsed(options: ParseSyncConfigOptions): ParsedSyncConfigSet {
+    let hydrationState: HydrationState;
+    const config = this.parseSingleConfig(options);
+
+    const storageConfig = this.getStorageConfig();
+    if (
+      storageConfig.versionedBuckets ||
+      config.config.compatibility.isEnabled(CompatibilityOption.versionedBucketIds)
+    ) {
+      hydrationState = versionedHydrationState(this.replicationStreamId);
+    } else {
+      hydrationState = DEFAULT_HYDRATION_STATE;
+    }
+
+    let hydrated: HydratedSyncConfig | undefined;
+    return {
+      replicationStreamId: this.replicationStreamId,
+      replicationStreamName: this.replicationStreamName,
+      syncConfigs: [config],
+      hydrationState,
+      get hydratedSyncConfig(): HydratedSyncConfig {
+        hydrated ??= config.config.hydrate({ hydrationState, sqlite: nodeSqlite(sqlite) });
+        return hydrated;
+      }
+    };
+  }
+
+  asUpdateOptions(options?: Omit<UpdateSyncRulesOptions, 'config'>): UpdateSyncRulesOptions {
+    // defaultSchema is not relevant for the parsed version here
+    const parsed = this.parseSingleConfig({ defaultSchema: 'not_applicable' });
+    return {
+      config: { yaml: this.sync_rules_content, plan: this.compiled_plan, parsed },
+      ...options
+    };
+  }
+
+  /**
+   * Fetch the current persisted state for this exact sync config.
+   */
+  abstract getSyncConfigStatus(): Promise<PersistedSyncConfigStatus | null>;
+}
+export interface PersistedSyncConfigContentData {
+  readonly replicationStreamId: number;
+  readonly sync_rules_content: string;
+  readonly compiled_plan: SerializedSyncPlan | null;
+  readonly replicationStreamName: string;
+  readonly storageVersion: number;
+
+  readonly syncConfigId?: PersistedSyncConfigId | null;
+}
+export type PersistedSyncConfigId = string;
+export interface ParseSyncConfigOptions {
+  defaultSchema: string;
+}

package/src/storage/PersistedSyncConfigStatus.ts

@@ -0,0 +1,14 @@
+import { SyncRuleState } from './BucketStorage.js';
+import { PersistedSyncConfigId } from './PersistedSyncConfigContent.js';
+
+export interface PersistedSyncConfigStatus {
+  readonly id: PersistedSyncConfigId;
+  readonly replicationStreamId: number;
+  readonly state: SyncRuleState;
+  readonly snapshot_done?: boolean;
+  readonly last_checkpoint_lsn: string | null;
+  readonly last_fatal_error?: string | null;
+  readonly last_fatal_error_ts?: Date | null;
+  readonly last_keepalive_ts?: Date | null;
+  readonly last_checkpoint_ts?: Date | null;
+}

package/src/storage/SourceEntity.ts

@@ -1,3 +1,5 @@
+import { SourceTableRef } from '@powersync/service-sync-rules';
+
 export interface ColumnDescriptor {
   name: string;
   /**
@@ -10,7 +12,7 @@ export interface ColumnDescriptor {
   typeId?: number;
 }
 
-export interface SourceEntityDescriptor {
+export interface SourceEntityDescriptor extends SourceTableRef {
   /**
    * The internal id of the source entity structure in the database.
    * If undefined, the schema and name are used as the identifier.
@@ -23,4 +25,10 @@ export interface SourceEntityDescriptor {
    *  The columns that are used to uniquely identify a record in the source entity.
    */
   replicaIdColumns: ColumnDescriptor[];
+  /**
+   * Whether the source always sends complete row data with each operation (e.g. Postgres REPLICA
+   * IDENTITY FULL). When true, no current_data copy is needed. Undefined means the source does not
+   * report this, in which case we default to keeping a copy.
+   */
+  sendsCompleteRows?: boolean;
 }

package/src/storage/SourceTable.ts

@@ -1,7 +1,14 @@
-import { DEFAULT_TAG } from '@powersync/service-sync-rules';
+import {
+  BucketDataSource,
+  BucketDefinitionId,
+  DEFAULT_TAG,
+  ParameterIndexId,
+  ParameterIndexLookupCreator,
+  SourceTableRef
+} from '@powersync/service-sync-rules';
 import { bson } from '../index.js';
 import * as util from '../util/util-index.js';
-import { ColumnDescriptor, SourceEntityDescriptor } from './SourceEntity.js';
+import { ColumnDescriptor } from './SourceEntity.js';
 
 /**
  * Format of the id depends on the bucket storage module. It should be consistent within the module.
@@ -10,12 +17,14 @@ export type SourceTableId = string | bson.ObjectId;
 
 export interface SourceTableOptions {
   id: SourceTableId;
-  connectionTag: string;
+  ref: SourceTableRef;
   objectId: number | string | undefined;
-  schema: string;
-  name: string;
   replicaIdColumns: ColumnDescriptor[];
   snapshotComplete: boolean;
+  bucketDataSources: BucketDataSource[];
+  parameterLookupSources: ParameterIndexLookupCreator[];
+  bucketDataSourceIds?: Set<BucketDefinitionId>;
+  parameterLookupSourceIds?: Set<ParameterIndexId>;
 }
 
 export interface TableSnapshotStatus {
@@ -24,7 +33,13 @@ export interface TableSnapshotStatus {
   lastKey: Uint8Array | null;
 }
 
-export class SourceTable implements SourceEntityDescriptor {
+/**
+ * Represents a resolved source table.
+ *
+ * There could be multiple of these for the same SourceTableRef.
+ * For that reason, we do not implement the SourceTableRef interface, to ensure that the two are not used interchangably.
+ */
+export class SourceTable {
   static readonly DEFAULT_TAG = DEFAULT_TAG;
 
   /**
@@ -46,14 +61,29 @@ export class SourceTable implements SourceEntityDescriptor {
   public syncParameters = true;
 
   /**
-   * True if the table is used in sync config for events.
+   * True if this table should fire events for row changes.
    *
-   * This value is resolved externally, and cached here.
+   * This value is resolved externally, and cached here. When multiple SourceTables exist
+   * for the same SourceTableRef (v3 storage), resolveTables designates exactly one of them
+   * as the event carrier, so that a row change saved once per table fires each event once.
    *
    * Defaults to true for tests.
    */
   public syncEvent = true;
 
+  /**
+   * True if raw data should be stored in current_data collection.
+   *
+   * This is needed when the source sends partial row data (e.g. TOAST values).
+   * When REPLICA IDENTITY FULL is configured, complete rows are always sent,
+   * so we don't need to store raw data.
+   *
+   * This value is resolved externally based on table configuration.
+   *
+   * Defaults to true for tests (conservative approach).
+   */
+  public storeCurrentData = true;
+
   /**
    * Always undefined if snapshotComplete = true.
    *
@@ -71,31 +101,47 @@ export class SourceTable implements SourceEntityDescriptor {
     return this.options.id;
   }
 
-  get connectionTag() {
-    return this.options.connectionTag;
-  }
-
   get objectId() {
     return this.options.objectId;
   }
 
   get schema() {
-    return this.options.schema;
+    return this.options.ref.schema;
   }
   get name() {
-    return this.options.name;
+    return this.options.ref.name;
+  }
+
+  get ref() {
+    return this.options.ref;
   }
 
   get replicaIdColumns() {
     return this.options.replicaIdColumns;
   }
 
+  get bucketDataSources() {
+    return this.options.bucketDataSources;
+  }
+
+  get parameterLookupSources() {
+    return this.options.parameterLookupSources;
+  }
+
+  get bucketDataSourceIds() {
+    return this.options.bucketDataSourceIds;
+  }
+
+  get parameterLookupSourceIds() {
+    return this.options.parameterLookupSourceIds;
+  }
+
   /**
-   *  Sanitized name of the entity in the format of "{schema}.{entity name}"
-   *  Suitable for safe use in Postgres queries.
+   * Sanitized name of the entity in the format of "{schema}.{entity name}".
+   * Suitable for safe use in Postgres queries.
    */
   get qualifiedName() {
-    return `${util.escapeIdentifier(this.schema)}.${util.escapeIdentifier(this.name)}`;
+    return util.qualifiedName(this.ref);
   }
 
   get syncAny() {
@@ -108,15 +154,20 @@ export class SourceTable implements SourceEntityDescriptor {
   clone() {
     const copy = new SourceTable({
       id: this.id,
-      connectionTag: this.connectionTag,
+      ref: this.options.ref,
       objectId: this.objectId,
-      schema: this.schema,
-      name: this.name,
       replicaIdColumns: this.replicaIdColumns,
-      snapshotComplete: this.snapshotComplete
+      snapshotComplete: this.snapshotComplete,
+      bucketDataSources: this.bucketDataSources,
+      parameterLookupSources: this.parameterLookupSources,
+      bucketDataSourceIds: this.bucketDataSourceIds == null ? undefined : new Set(this.bucketDataSourceIds),
+      parameterLookupSourceIds:
+        this.parameterLookupSourceIds == null ? undefined : new Set(this.parameterLookupSourceIds)
     });
     copy.syncData = this.syncData;
     copy.syncParameters = this.syncParameters;
+    copy.syncEvent = this.syncEvent;
+    copy.storeCurrentData = this.storeCurrentData;
     copy.snapshotStatus = this.snapshotStatus;
     return copy;
   }