@fgv/ts-res 5.0.0-2 → 5.0.0-21

package/src/packlets/decisions/decision.ts

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { captureResult, Collections, Hash, Result } from '@fgv/ts-utils';
+import { Convert as CommonConvert, DecisionIndex, DecisionKey } from '../common';
+import { JsonValue } from '@fgv/ts-json-base';
+import { Candidate, ICandidate } from './candidate';
+import { IDecision } from './common';
+import { ConditionSet } from '../conditions';
+
+/**
+ * Parameters used to create a new {@link Decisions.Decision | Decision}
+ * with the {@link Decisions.Decision.createDecision | createDecision}
+ * static method.
+ * @public
+ */
+export interface IDecisionCreateParams<TVALUE extends JsonValue = JsonValue> {
+  candidates: ReadonlyArray<ICandidate<TVALUE>>;
+  index?: number;
+}
+
+/**
+ * Parameters used to construct a new {@link Decisions.Decision | Decision} with
+ * the protected constructor.
+ * @public
+ */
+export interface IDecisionConstructorParams<TVALUE extends JsonValue = JsonValue>
+  extends IDecisionCreateParams<TVALUE> {
+  isAbstract: boolean;
+}
+
+/**
+ * Simple collectible implementation of {@link Decisions.IDecision | IDecision}.
+ * @public
+ */
+export class Decision<TVALUE extends JsonValue = JsonValue> implements IDecision<TVALUE> {
+  /**
+   * The sorted {@link Conditions.ConditionSet  | ConditionSets} that make up this decision.
+   * @public
+   */
+  public readonly candidates: ReadonlyArray<Candidate<TVALUE>>;
+
+  /**
+   * Unique global key for this decision, derived from the contents
+   * of the decision.
+   */
+  public get key(): DecisionKey {
+    return this._collectible.key;
+  }
+
+  /**
+   * Unique global index for this decision.
+   */
+  public get index(): DecisionIndex | undefined {
+    return this._collectible.index;
+  }
+
+  /**
+   * Key for the empty decision (no condition sets).
+   */
+  public static readonly EmptyDecisionKey: DecisionKey = CommonConvert.decisionKey.convert('').orThrow();
+
+  /**
+   * Key for the default-only decision (single condition set with no conditions).
+   */
+  public static readonly DefaultOnlyDecisionKey: DecisionKey = CommonConvert.decisionKey
+    .convert('00000000')
+    .orThrow();
+
+  private _collectible: Collections.Collectible<DecisionKey, DecisionIndex>;
+
+  /**
+   * Constructor for a {@link Decisions.Decision | Decision} object.
+   * @param params - {@link Decisions.IDecisionConstructorParams | Parameters} used to create the decision.
+   * @public
+   */
+  protected constructor(params: IDecisionConstructorParams<TVALUE>) {
+    this.candidates = Array.from(params.candidates)
+      .map((c) => Candidate.createCandidate(c).orThrow())
+      .sort(Candidate.compare)
+      .reverse();
+
+    /* c8 ignore next 3 - coverage having a rough time */
+    const key = params.isAbstract
+      ? Decision.getAbstractKey(this.candidates.map((c) => c.conditionSet))
+      : Decision.getKey(this.candidates);
+
+    this._collectible = new Collections.Collectible<DecisionKey, DecisionIndex>({
+      key,
+      index: params.index,
+      indexConverter: CommonConvert.decisionIndex
+    });
+  }
+
+  /**
+   * Creates a new {@link Decisions.Decision | Decision} object.
+   * @param params - {@link Decisions.IDecisionCreateParams | Parameters} used to create the decision.
+   * @returns `Success` with the new decision if successful, or `Failure` with an error message if not.
+   * @public
+   */
+  public static createDecision(params: IDecisionCreateParams): Result<Decision> {
+    return captureResult(() => new Decision({ ...params, isAbstract: false }));
+  }
+
+  /**
+   * Sets the index for this decision.  Once set, index is immutable.
+   * @param index - The index to set.
+   * @returns `Success` with the new index if successful, or `Failure` with an error message if not.
+   * @public
+   */
+  public setIndex(index: number): Result<DecisionIndex> {
+    return this._collectible.setIndex(index);
+  }
+
+  /**
+   * Helper function to return a stable key for a the condition sets that
+   * make up a {@link Decisions.Decision | decision}.  The abstract
+   * key is a `+`-separated list of the hashes of the sorted condition sets
+   * that make up the decision.
+   * @param conditionSets - The condition sets to use to create the key.
+   * @returns A key derived from the condition set hashes.
+   * @public
+   */
+  public static getAbstractKey(conditionSets: ReadonlyArray<ConditionSet>): DecisionKey {
+    return CommonConvert.decisionKey
+      .convert(
+        Array.from(conditionSets)
+          .sort(ConditionSet.compare)
+          .reverse()
+          .map((c) => c.toHash())
+          .join('+')
+      )
+      .orThrow();
+  }
+
+  /**
+   * Helper function to return a stable key for a set of condition sets.
+   * @param conditionSets - The condition sets to use to create the key.
+   * @returns A key derived from the condition set hashes.
+   * @public
+   */
+  public static getKey<TVALUE extends JsonValue = JsonValue>(
+    candidates: ReadonlyArray<ICandidate<TVALUE>>
+  ): DecisionKey {
+    if (candidates.length === 0) {
+      /* c8 ignore next 2 - functional code path tested but coverage intermittently missed */
+      return Decision.EmptyDecisionKey;
+    }
+    const abstractKey = Decision.getAbstractKey(candidates.map((c) => c.conditionSet));
+    const valueKey = Hash.Crc32Normalizer.crc32Hash(candidates.map((c) => JSON.stringify(c.value)));
+    return CommonConvert.decisionKey.convert(`${abstractKey}|${valueKey}`).orThrow();
+  }
+}

package/src/packlets/decisions/index.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export * from './common';
+export * from './candidate';
+export * from './decision';
+export * from './abstractDecision';
+export * from './abstractDecisionCollector';
+export * from './concreteDecision';

package/src/packlets/import/fsItem.ts

@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import {
+  captureResult,
+  DetailedResult,
+  FileTree,
+  mapResults,
+  Result,
+  fail,
+  succeed,
+  useOrInitialize
+} from '@fgv/ts-utils';
+import { Helpers as CommonHelpers, Validate } from '../common';
+import * as Conditions from '../conditions';
+import { IReadOnlyQualifierCollector } from '../qualifiers';
+import { ImportContext } from './importContext';
+
+/**
+ * Result details for {@link Import.FsItem | FsItem} operations.
+ * @public
+ */
+export type FsItemResultDetail = 'failed' | 'skipped' | 'succeeded';
+
+/**
+ * Interface describing some single file system item.
+ * @public
+ */
+export interface IFsItemProps {
+  /**
+   * The underlying `FileTreeItem` for this item.
+   */
+  readonly item: FileTree.FileTreeItem;
+
+  /**
+   * The base name of the file system item, once
+   * any conditions set tokens have been removed.
+   */
+  readonly baseName: string;
+
+  /**
+   * {@link Conditions.IValidatedConditionDecl | Conditions} extracted
+   * from the base name of the {@link Import.FsItem | FsItem}.
+   */
+  readonly conditions: Conditions.IValidatedConditionDecl[];
+}
+
+/**
+ * Class describing some file system item to be imported.
+ * @public
+ */
+export class FsItem implements IFsItemProps {
+  /**
+   * {@inheritDoc Import.IFsItemProps.baseName}
+   */
+  public readonly baseName: string;
+
+  /**
+   * {@inheritDoc Import.IFsItemProps.conditions}
+   */
+  public readonly conditions: Conditions.IValidatedConditionDecl[];
+
+  /**
+   * {@inheritDoc Import.IFsItemProps.item}
+   */
+  public readonly item: FileTree.FileTreeItem;
+
+  /**
+   * The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} to use for this item.
+   */
+  public readonly qualifiers: IReadOnlyQualifierCollector;
+
+  /**
+   * Protected constructor creates a new {@link Import.FsItem | FsItem}.
+   * @param props - The {@link Import.IFsItemProps | file system item properties} to use for this item.
+   * @param qualifiers - The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} used to parse
+   * embedded condition set tokens.
+   * @param tree - file tree implementation to use for this item.
+   * @returns `Success` containing the new {@link Import.FsItem | FsItem} if successful, or a `Failure`
+   * containing an error message if not.
+   */
+  protected constructor(props: IFsItemProps, qualifiers: IReadOnlyQualifierCollector) {
+    const { baseName, conditions, item } = props;
+    this.baseName = baseName;
+    this.conditions = conditions;
+    this.item = item;
+    this.qualifiers = qualifiers;
+  }
+
+  /**
+   * Creates a new {@link Import.FsItem | FsItem} from a `FileTreeItem`.
+   * @param item - The `FileTreeItem` to import.
+   * @param qualifiers - The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} used to parse
+   * embedded condition set tokens.
+   * @returns `Success` containing the new {@link Import.FsItem | FsItem} if successful, or a `Failure`
+   * containing an error message if not.  Note that the result detail `skipped` indicates that the item
+   * was not created because it is not relevant - this is a soft error that should be silently ignored.
+   */
+  public static createForItem(
+    item: FileTree.FileTreeItem,
+    qualifiers: IReadOnlyQualifierCollector
+  ): DetailedResult<FsItem, FsItemResultDetail> {
+    const baseName: string = item.type === 'file' ? item.baseName : item.name;
+
+    return FsItem.tryParseBaseName(baseName, qualifiers)
+      .withErrorFormat((msg) => `${baseName}: error extracting conditions - ${msg}`)
+      .onSuccess(({ baseName: newBaseName, conditions }) => {
+        return captureResult(() => new FsItem({ baseName: newBaseName, conditions, item }, qualifiers));
+      })
+      .withDetail('failed', 'succeeded');
+  }
+
+  /**
+   * Creates a new {@link Import.FsItem | FsItem} from a file system path.
+   * @param importPath - The path to the file system item to import.
+   * @param qualifiers - The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} used to parse
+   * embedded condition set tokens.
+   * @param fs - An optional {@link Import.IImporterFilesystem | file system implementation} to use for this item.
+   * @returns `Success` containing the new {@link Import.FsItem | FsItem} if an item is created
+   * successfully, or a `Failure` containing an error message if it is not.  Note that the result detail
+   * `skipped` indicates that the item was not created because it is not relevant - this is a soft error
+   * that should be silently ignored.
+   */
+  public static createForPath(
+    importPath: string,
+    qualifiers: IReadOnlyQualifierCollector,
+    tree?: FileTree.FileTree
+  ): DetailedResult<FsItem, FsItemResultDetail> {
+    return useOrInitialize(tree, () => FileTree.forFilesystem())
+      .withDetail<FsItemResultDetail>('failed', 'succeeded')
+      .onSuccess((tree) => {
+        return tree
+          .getItem(importPath)
+          .withDetail<FsItemResultDetail>('failed')
+          .onSuccess((item) => FsItem.createForItem(item, qualifiers));
+      });
+  }
+
+  /**
+   * Tries to parse a base name into a base name and a set of conditions.
+   * @param baseName - The base name to parse.
+   * @param qualifiers - The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} used to parse
+   * embedded condition set tokens.
+   * @returns `Success` containing the parsed base name and conditions on success, or `Failure` containing
+   * an error message if it is not.
+   */
+  public static tryParseBaseName(
+    baseName: string,
+    qualifiers: IReadOnlyQualifierCollector
+  ): Result<Omit<IFsItemProps, 'item'>> {
+    const nameParts = baseName.split('.');
+    const segmentToTest = nameParts.length > 1 ? nameParts[nameParts.length - 1] : nameParts[0];
+    const validatedConditions = CommonHelpers.parseConditionSetTokenParts(segmentToTest).onSuccess(
+      (parts) => {
+        return mapResults(
+          parts.map((part) => Conditions.ConditionTokens.validateConditionTokenParts(part, qualifiers))
+        ).onFailure((msg) => {
+          if (parts.length === 1 && parts[0].qualifier === undefined) {
+            return succeed([]);
+          }
+          return fail(msg);
+        });
+      }
+    );
+    if (validatedConditions.isFailure()) {
+      return fail(validatedConditions.message);
+    }
+    const conditions = validatedConditions.value;
+    if (conditions.length > 0) {
+      baseName = nameParts.filter((s) => s !== segmentToTest).join('.');
+    }
+    return succeed({ baseName, conditions });
+  }
+
+  /**
+   * Gets the context for this file system item.
+   * @returns `Success` containing the {@link Import.ImportContext | import context} for this item
+   * if successful, or a `Failure` containing an error message if an error occurs.
+   */
+  public getContext(): Result<ImportContext> {
+    return Validate.toOptionalResourceId(this.baseName).onSuccess((baseId) => {
+      const conditions = this.conditions.map((c) => {
+        return {
+          qualifierName: c.qualifier.name,
+          value: c.value,
+          operator: c.operator,
+          priority: c.priority
+        };
+      });
+      return ImportContext.create({ baseId, conditions });
+    });
+  }
+}

package/src/packlets/import/importContext.ts

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Helpers } from '../common';
+import { captureResult, Result, succeed } from '@fgv/ts-utils';
+import { IConditionDecl } from '../conditions';
+import { ResourceId } from '../common';
+import * as ResourceJson from '../resource-json';
+
+/**
+ * Accumulated context of a resource import operation.
+ * @public
+ */
+export interface IImportContext {
+  /**
+   * Base ID for the import context for resources imported
+   * in this context.
+   */
+  readonly baseId?: string;
+  /**
+   * Conditions to be applied to resources imported in this context.
+   */
+  readonly conditions?: ReadonlyArray<IConditionDecl>;
+}
+
+/**
+ * Accumulated context of a resource import operation.
+ * @public
+ */
+export interface IValidatedImportContext {
+  /**
+   * Base ID for the import context for resources imported
+   * in this context.
+   */
+  readonly baseId?: ResourceId;
+  /**
+   * Conditions to be applied to resources imported in this context.
+   */
+  readonly conditions: ReadonlyArray<IConditionDecl>;
+}
+
+/**
+ * Class to accumulate context for a resource import operation.
+ * @public
+ */
+export class ImportContext implements IValidatedImportContext {
+  /**
+   * {@inheritdoc Import.IImportContext.baseId}
+   */
+  public readonly baseId: ResourceId | undefined;
+
+  /**
+   * {@inheritdoc Import.IImportContext.conditions}
+   */
+  public readonly conditions: ReadonlyArray<IConditionDecl>;
+
+  /**
+   * Protected {@link Import.ImportContext | import context} for derived classes.
+   * Public consumers use {@link Import.ImportContext.create | create} to create new instances.
+   * @param baseId - The base ID for the import context.
+   * @param conditions - Conditions to be applied to resources imported in this context.
+   */
+  protected constructor({ baseId, conditions }: IImportContext) {
+    this.baseId = Helpers.joinOptionalResourceIds(baseId).orThrow();
+    this.conditions = Array.from(conditions ?? []);
+  }
+
+  /**
+   * Factory method to create a new {@link Import.ImportContext | import context}.
+   * @param context - The {@link Import.IImportContext | import context} to create
+   * the new context from.
+   * @returns `Success` with the new {@link Import.ImportContext | import context}
+   * if successful, or `Failure` with an error message if creation fails.
+   */
+  public static create(context?: IImportContext): Result<ImportContext> {
+    /* c8 ignore next */
+    context = context ?? { conditions: [] };
+    return captureResult(() => new ImportContext(context));
+  }
+
+  /**
+   * Adds conditions to the import context.
+   * @param conditions - Conditions to be added to the import context.
+   * @returns `Success` with a new {@link Import.ImportContext | import context} containing the added conditions
+   * if successful, or `Failure` with an error message if the operation fails.
+   */
+  public withConditions(conditions: IConditionDecl[]): Result<ImportContext> {
+    return ImportContext.create({
+      baseId: this.baseId,
+      conditions: [...this.conditions, ...conditions]
+    });
+  }
+
+  /**
+   * Appends names to the base ID of the import context.
+   * @param name - The base name to set.
+   * @returns `Success` with a new {@link Import.ImportContext | import context} containing the new base ID
+   * if successful, or `Failure` with an error message if the operation fails.
+   */
+  public withName(...names: string[]): Result<ImportContext> {
+    return Helpers.joinResourceIds(this.baseId, ...names).onSuccess((baseId) => {
+      return ImportContext.create({ baseId, conditions: this.conditions });
+    });
+  }
+
+  /**
+   * Extends the import context with additional name segments and conditions.
+   * @param context - The {@link Import.IImportContext | import context} to extend this context with.
+   * @returns `Success` with a new {@link Import.ImportContext | import context}
+   * containing the extended context if successful, or `Failure` with an error
+   * message if the operation fails.
+   */
+  public extend(context?: IValidatedImportContext): Result<ImportContext> {
+    /* c8 ignore next 1 */
+    context = context ?? { conditions: [] };
+    const conditions = [...this.conditions, ...context.conditions];
+    return Helpers.joinOptionalResourceIds(this.baseId, context.baseId).onSuccess((baseId) => {
+      return ImportContext.create({ baseId, conditions });
+    });
+  }
+
+  /**
+   * Creates a new {@link Import.ImportContext | import context} to import resources from a
+   * container with the specified {@link ResourceJson.Normalized.IContainerContextDecl | container context declaration}e
+   * @param container - The {@link ResourceJson.Normalized.IContainerContextDecl | container context declaration}
+   * to consider when creating the new context.
+   * @param importer - The base {@link Import.ImportContext | import context} to adjust for the container
+   * context.
+   * @returns `Success` with the new {@link Import.ImportContext | import context} if successful,
+   * or `Failure` with an error message if the operation fails.
+   * @remarks
+   * A container context declaration may specify a merge method, which determines how the
+   * container context is merged with the base context. The merge method can be one of the following:
+   * - `augment`: The base context is augmented with the container context. This is the default behavior.
+   * - `replace`: The base context is selectively replaced with the container context. If the container context
+   *   specifies a base ID or conditions, the corresponding values in the base context are ignored.
+   * - `delete`: The base context is deleted. This means that the container context is not used at all.
+   */
+  public static forContainerImport(
+    container?: ResourceJson.Normalized.IContainerContextDecl,
+    importer?: ImportContext
+  ): Result<ImportContext | undefined> {
+    if (!importer) {
+      return succeed(undefined);
+    }
+    /* c8 ignore next 1 */
+    container = container ?? {};
+    const mergeMethod = container.mergeMethod ?? 'augment';
+
+    switch (mergeMethod) {
+      case 'augment':
+        return succeed(importer);
+      case 'replace': {
+        // if the container defines baseId or conditions, then we ignore
+        // the corresponding values in the importer
+        const baseId = container.baseId ? undefined : importer.baseId;
+        const conditions = container.conditions ? undefined : importer.conditions;
+        return ImportContext.create({ baseId, conditions });
+      }
+      case 'delete':
+        return succeed(undefined);
+    }
+  }
+}