@roster-lock/shared 0.1.0

package/src/match-lock-file/match-config/version-1/usage/calculatePieceVersion.ts

@@ -0,0 +1,85 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+
+type PieceDefinition = RosterLockV1Config["engine"]["pieceDefinitions"][string];
+type EngineAssetDefinition = PieceDefinition["assets"][number];
+
+type FileWithSha = { path: string, asset: EngineAssetDefinition, sha: string }
+type FileGetter = (path: string) => Promise<{ byteSize: number, stream: AsyncIterable<Uint8Array> }>
+type ProgressListener = (progress: { file: string, current: number, total: number }) => any
+export async function calculatePieceVersion(
+  files: Map<string, { assets: Array<EngineAssetDefinition> }>,
+  getFile: FileGetter,
+  onProgress?: ProgressListener
+){
+  const logicFiles: Array<FileWithSha> = [];
+  const mediaFiles: Array<FileWithSha> = [];
+  const docFiles: Array<FileWithSha> = [];
+
+  await Promise.all(Array.from(files.entries()).map(async ([relativePath, { assets }]) => {
+    const sha = await getHashFromFile(relativePath, getFile, onProgress);
+    const asset = assets[0];
+    if(!asset) throw new Error(`No asset found for ${relativePath}`);
+    switch(asset.classification){
+      case "logic": logicFiles.push({ path: relativePath, asset, sha }); break;
+      case "media": mediaFiles.push({ path: relativePath, asset, sha }); break;
+      case "doc": docFiles.push({ path: relativePath, asset, sha }); break;
+      default: throw new Error(`Unknown asset type ${asset.classification}`);
+    }
+  }));
+
+  return {
+    logic: await calculateComnbinedHash(logicFiles.sort(shaSort)),
+    media: await calculateComnbinedHash(mediaFiles.sort(shaSort)),
+    docs: await calculateComnbinedHash(docFiles.sort(shaSort)),
+  }
+}
+
+function shaSort(a: FileWithSha, b: FileWithSha){
+  return a.sha.localeCompare(b.sha);
+}
+
+async function getHashFromFile(
+  file: string, getFile: FileGetter, onProgress?: ProgressListener
+){
+  try {
+    const { stream, byteSize } = await getFile(file);
+    const buffer = new Uint8Array(byteSize);
+    let consumed = 0;
+    for await (const chunk of stream){
+      buffer.set(chunk, consumed);
+      consumed += chunk.byteLength;
+      onProgress && onProgress({ file, current: consumed, total: byteSize });
+    }
+    return toHex(await crypto.subtle.digest("SHA-256", buffer));
+  }catch(e){
+    throw new Error("Failed to calculate Hash from file")
+  }
+}
+
+
+async function calculateComnbinedHash(files: Array<FileWithSha>){
+  if (files.length === 0) {
+    return toHex(await crypto.subtle.digest("SHA-256", new Uint8Array(0)));
+  }
+
+  // Create our array with expected length ahead of time
+  const buffer = new Uint8Array(files.length * 32);
+  let offset = 0;
+  for(const { sha } of files){
+    for (let i = 0; i < sha.length; i += 2) {
+      // For each 2 characters
+      // Try to parse those two chararacters as if it were a hex value
+      const byte = Number.parseInt(sha.substring(i, i + 2), 16)
+      // If parsing failed, we failed
+      if(Number.isNaN(byte)) throw new Error(`Invalid SHA: ${sha}`);
+      // If we're ok, we set the byte on the offset directly
+      buffer[offset++] = byte;
+    }
+  }
+  return toHex(await crypto.subtle.digest("SHA-256", buffer));
+}
+
+function toHex(buffer: ArrayBuffer): string {
+  return Array.from(new Uint8Array(buffer)).map(b => b.toString(16).padStart(2, "0")).join("");
+}
+

package/src/match-lock-file/match-config/version-1/usage/empty-configs.ts

@@ -0,0 +1,61 @@
+import { RosterLockV1Config, RosterLockV1Draft } from "@roster-lock/types";
+import { cloneJSON } from "@roster-lock/utils";
+
+export const EMPTY_ROSTER_LOCK: RosterLockV1Config = {
+  configIdentity: { namespace: "roster-lock", purpose: "lock", version: 1 },
+  author: "",
+  title: "",
+  version: "0.0.0",
+  engine: { name: "", version: "", pieceDefinitions: {} },
+  rosters: {},
+  selection: { piece: {}, globalValidation: [], scriptDictionary: {}, },
+  pieceMeta: {},
+}
+
+export const EMPTY_ROSTER_DRAFT: RosterLockV1Draft = {
+  configIdentity: { namespace: "roster-lock", purpose: "draft", version: 1 },
+  previousLock: cloneJSON(EMPTY_ROSTER_LOCK),
+  stagedLock: cloneJSON(EMPTY_ROSTER_LOCK),
+  draft: {
+    rosterPieceInfo: {},
+    selectionScriptInfo: {},
+  }
+};
+
+import {
+  SelectionGameControlledConfig,
+  SelectionNormalConfig,
+  SelectionPreselectedConfig,
+  SelectionUnselectableConfig,
+  SelectionPieceMeta,
+  JSONShallowObject,
+} from "@roster-lock/types";
+export const EMPTY_ROSTER_GAME_SELECTION: SelectionGameControlledConfig = {
+  type: "game-controlled",
+}
+
+export const EMPTY_ROSTER_NORMAL_SELECTION: SelectionNormalConfig = {
+  type: "normal",
+  validation: {
+    count: "*",
+    unique: false,
+    banList: [],
+    customValidation: []
+  },
+  mergeAlgorithm: void 0
+}
+
+export const EMPTY_ROSTER_PRESELECTED_SELECTION: SelectionPreselectedConfig = {
+  type: "preselected",
+  pieces: []
+}
+
+export const EMPTY_ROSTER_UNSELECTABLE_SELECTION: SelectionUnselectableConfig = {
+  type: "unselectable",
+}
+
+export const EMPTY_PIECE_META: SelectionPieceMeta<JSONShallowObject> = {
+  schema: {},
+  defaultMeta: {},
+  values: {},
+}

package/src/match-lock-file/match-config/version-1/usage/files-and-assets/constants.ts

@@ -0,0 +1,6 @@
+
+import { PATH_ROSTERLOCK_PIECE_INFO } from "../../piece-info"
+
+export const FILES_TO_IGNORE = [
+  PATH_ROSTERLOCK_PIECE_INFO
+];

package/src/match-lock-file/match-config/version-1/usage/files-and-assets/getAssetsOfFiles.ts

@@ -0,0 +1,88 @@
+import { FILES_TO_IGNORE } from "./constants";
+
+import { getMatchingAssetsForFile } from "./getMatchingAsset";
+
+import { PieceDefinition, EngineAssetDefinition } from "./types";
+
+export { getMatchingAssetsForFile };
+
+export async function getAssetsOfFiles(
+  files: Iterable<string> | AsyncIterable<string>,
+  pathVariables: Record<string, string>,
+  pieceDefinition: PieceDefinition,
+): Promise<{
+  assetsWithFiles: Map<string, { asset: EngineAssetDefinition, files: Array<string> }>
+  filesWithAssets: Map<string, { assets: Array<EngineAssetDefinition> }>
+}>{
+  const assetCounts = new Map<string, { files: Array<string>, asset: EngineAssetDefinition }>();
+  const fileCounts = new Map<string, { assets: Array<EngineAssetDefinition> }>();
+  for await (const filePath of files){
+    if(FILES_TO_IGNORE.includes(filePath)) continue;
+
+    const assetMatching = getMatchingAssetsForFile(pieceDefinition, pathVariables, filePath);
+    const asset = assetMatching[0];
+    if(!asset){
+      // Error: File doesn't match any assets
+      fileCounts.set(filePath, { assets: [] });
+      continue;
+    }
+    if(assetMatching.length > 1){
+      // Warning: File matches multiple assets
+    }
+    const currentCount = ((): { files: Array<string>, asset: EngineAssetDefinition } =>{
+      const currentCount = assetCounts.get(asset.name);
+      if(currentCount) return currentCount;
+      const newCount = { files: [], asset: asset };
+      assetCounts.set(asset.name, newCount);
+      return newCount;
+    })();
+
+    currentCount.files.push(filePath);
+    fileCounts.set(filePath, { assets: assetMatching });
+  }
+
+  for(const asset of pieceDefinition.assets){
+    const currentCountInfo = assetCounts.get(asset.name);
+    if(!currentCountInfo){
+      // Error: Asset has no files
+      assetCounts.set(asset.name, { files: [], asset });
+    }
+  }
+
+  return { filesWithAssets: fileCounts, assetsWithFiles: assetCounts };
+}
+
+import { isValidAssetFileCount, validateAssetFileCount } from "./validateAssetFileCount";
+export function collectAssetFileErrors(
+  { assetsWithFiles, filesWithAssets }: Awaited<ReturnType<typeof getAssetsOfFiles>>
+){
+  const errors: Array<{ type: "asset" | "file", id: string, message: string }> = [];
+  for(const [assetName, { asset, files }] of assetsWithFiles){
+    try {
+      if(files.length === 0 && !isValidAssetFileCount(asset.count, 0)){
+        errors.push({
+          type: "asset",
+          id: assetName,
+          message: `Asset is expected to have files`,
+        });
+        continue;
+      }
+      validateAssetFileCount(asset.count, files.length);
+    }catch(e){
+      errors.push({
+        type: "asset",
+        id: assetName,
+        message: (e as Error).message,
+      });
+    }
+  }
+  for(const [filePath, { assets }] of filesWithAssets){
+    if(assets.length === 0) errors.push({
+      type: "file",
+      id: filePath,
+      message: "File has no matching assets",
+    });
+  }
+  return errors;
+}
+

package/src/match-lock-file/match-config/version-1/usage/files-and-assets/getMatchingAsset.ts

@@ -0,0 +1,42 @@
+import micromatch from "micromatch";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockEngineConfig = RosterLockV1Config["engine"];
+
+import { validatePathVariableValue } from "../../lock/rosters/validate";
+/**
+ * Test a single file against piece definition assets
+ */
+export function getMatchingAssetsForFile(
+  pieceDefinition: RosterLockEngineConfig['pieceDefinitions'][string],
+  pathVariables: Record<string, string>,
+  relativePath: string,
+): Array<RosterLockEngineConfig['pieceDefinitions'][string]['assets'][number]> {
+
+  for(const variableValue of Object.values(pathVariables)){
+    validatePathVariableValue(variableValue);
+  }
+
+  return pieceDefinition.assets.filter((asset) =>(
+    asset.glob.some((glob)=>{
+      // Replace path variables
+      glob = replacePathVariables(glob, pathVariables);
+      // check if the relativePath is exactly the glob
+      // TODO: eventually we want to see if the glob is a file path and if so, check for exact match
+      // Relative path isn't expected to have any glob parts, so an exact match is expected to be ok
+      // If a filepath can have glob parts, we may be in trouble
+      if(relativePath === glob) return true;
+      // check if the relativePath matches the glob
+      if(micromatch.isMatch(relativePath, glob)) return true;
+      return false;
+    })
+  ));
+}
+
+function replacePathVariables(
+  glob: string, pathVariables: Record<string, string>
+){
+  for(const [variableName, value] of Object.entries(pathVariables)){
+    glob = glob.replaceAll(`<${variableName}>`, value);
+  }
+  return glob;
+}

package/src/match-lock-file/match-config/version-1/usage/files-and-assets/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./getAssetsOfFiles";
+export * from "./getMatchingAsset";
+export * from "./validateAssetFileCount";

package/src/match-lock-file/match-config/version-1/usage/files-and-assets/types.ts

@@ -0,0 +1,5 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+
+export type PieceDefinition = RosterLockV1Config["engine"]["pieceDefinitions"][string];
+
+export type EngineAssetDefinition = PieceDefinition["assets"][number];

package/src/match-lock-file/match-config/version-1/usage/files-and-assets/validateAssetFileCount.ts

@@ -0,0 +1,34 @@
+import { EngineAssetDefinition } from "./types";
+
+export function validateAssetFileCount(
+  validator: EngineAssetDefinition["count"],
+  actualCount: number
+){
+  if(!Array.isArray(validator)){
+    if(validator === "*") return;
+    if(actualCount !== validator){
+      throw new Error(`Expected ${validator} files, got ${actualCount}`);
+    }
+    return;
+  }
+  const [min, max] = validator;
+  if(actualCount < min){
+    throw new Error(`Expected at least ${min} files, got ${actualCount}`);
+  }
+  if(max === "*") return;
+  if(actualCount > max){
+    throw new Error(`Expected at most ${max} files, got ${actualCount}`);
+  }
+}
+
+export function isValidAssetFileCount(
+  validator: EngineAssetDefinition["count"],
+  actualCount: number
+){
+  try {
+    validateAssetFileCount(validator, actualCount);
+    return true;
+  }catch(e){
+    return false;
+  }
+}

package/src/match-lock-file/match-config/version-1/usage/index.ts

@@ -0,0 +1,6 @@
+
+export * from "./files-and-assets";
+export * from "./validate-select";
+export * from "./calculatePieceVersion";
+export * from "./empty-configs";
+export * from "./publish";

package/src/match-lock-file/match-config/version-1/usage/publish/SemVer.ts

@@ -0,0 +1,67 @@
+import { JSON_Unknown } from "@roster-lock/utils";
+
+export class SemVer {
+  private updateStatus: "none" | "patch" | "minor" | "major" = "none";
+  v: {
+    major: number,
+    minor: number,
+    patch: number
+  }
+  reasons: {
+    major: Array<{ reason: string, info: JSON_Unknown }>,
+    minor: Array<{ reason: string, info: JSON_Unknown }>,
+    patch: Array<{ reason: string, info: JSON_Unknown }>
+  } = {
+    major: [],
+    minor: [],
+    patch: [],
+  }
+  constructor(value: string){
+    const parts = value.split(".");
+    if(parts.length !== 3) throw new Error("Invalid Semver string");
+    this.v = {
+      major: SemVer.validateVersion(parts[0], "major"),
+      minor: SemVer.validateVersion(parts[1], "minor"),
+      patch: SemVer.validateVersion(parts[2], "patch"),
+    }
+    if(value !== this.toString()){
+      throw new Error("Invalid Semver string")
+    }
+  }
+
+  addMajor(reason: string, info: JSON_Unknown = {}){
+    this.reasons.major.push({ reason, info });
+    if(this.updateStatus === "major") return;
+    this.updateStatus = "major";
+    this.v.major += 1;
+    this.v.minor = 0;
+    this.v.patch = 0;
+  }
+  addMinor(reason: string, info: JSON_Unknown = {}){
+    this.reasons.minor.push({ reason, info });
+    if(this.updateStatus === "minor") return;
+    this.updateStatus = "minor";
+    this.v.minor += 1;
+    this.v.patch = 0;
+  }
+  addPatch(reason: string, info: JSON_Unknown = {}){
+    this.reasons.patch.push({ reason, info });
+    if(this.updateStatus === "patch") return;
+    this.updateStatus = "patch";
+    this.v.patch += 1
+  }
+
+  toString(){
+    return [this.v.major, this.v.minor, this.v.patch].join(".")
+  }
+
+  getReasons(){
+    return this.reasons;
+  }
+
+  static validateVersion(value: string, partName: string){
+    const v = Number.parseInt(value)
+    if(Number.isNaN(v)) throw new Error(`Invalid Semver string: ${partName} version not an integer`)
+    return v
+  }
+}

package/src/match-lock-file/match-config/version-1/usage/publish/diffLocks.ts

@@ -0,0 +1,66 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+import { diff } from 'json-diff-ts';
+import { SemVer } from "./SemVer";
+
+
+export function diffLocks(oldLock: RosterLockV1Config, newLock: RosterLockV1Config){
+  const versionTracker = new SemVer(oldLock.version);
+
+  diffRosters(versionTracker, oldLock, newLock);
+
+  return versionTracker;
+}
+
+function diffRosters(versionTracker: SemVer, oldLock: RosterLockV1Config, newLock: RosterLockV1Config){
+  const oldPieceCollections = Object.entries(oldLock.rosters);
+  const newPieceCollectionKeys = Object.keys(newLock.rosters);
+
+  const missingCollections: Array<string> = [];
+  const addedCollections = new Set(newPieceCollectionKeys);
+
+  for(const [key, oldPieces] of oldPieceCollections){
+    const newPieces = newLock.rosters[key];
+    if(!newPieces){
+      versionTracker.addMajor("Missing Piece Collection", { collectionName: key });
+      missingCollections.push(key);
+      continue;
+    }
+    addedCollections.delete(key);
+    diffPieces(versionTracker, key, oldPieces, newPieces)
+  }
+  for(const key of addedCollections){
+    versionTracker.addMajor("New Piece Collection", { collectionName: key });
+  }
+
+  return versionTracker
+}
+
+
+type PieceCollection = RosterLockV1Config["rosters"][string]
+type Piece = PieceCollection[number];
+function diffPieces(versionTracker: SemVer, collection: string, oldLock: PieceCollection, newLock: PieceCollection){
+  const newPieces = new Map<string, Piece>()
+  for(const newPiece of newLock){
+    newPieces.set(newPiece.version.logic, newPiece)
+  }
+  for(const oldPiece of oldLock){
+    const newPiece = newPieces.get(oldPiece.version.logic)
+    if(!newPiece){
+      versionTracker.addMajor(
+        "Removed a Piece", { collection, id: oldPiece.id, logic: oldPiece.version.logic }
+      )
+      continue;
+    }
+    newPieces.delete(oldPiece.version.logic)
+    if(diff(oldPiece, newPiece)){
+      versionTracker.addPatch(
+        "Updated non gameplay piece info", { collection, id: oldPiece.id, old: oldPiece.downloadSources, new: newPiece.downloadSources }
+      )
+    }
+  }
+  for(const [logic, newPiece] of newPieces){
+    versionTracker.addMinor(
+      "Added a Piece", { collection, id: newPiece.id, logic }
+    )
+  }
+}

package/src/match-lock-file/match-config/version-1/usage/publish/index.ts

@@ -0,0 +1,2 @@
+export * from "./SemVer";
+export * from "./diffLocks";

package/src/match-lock-file/match-config/version-1/usage/validate-select/constants.ts

@@ -0,0 +1,9 @@
+
+
+export class RunUntrustedError extends Error {
+  constructor(
+    public scriptSrc: string, message: string, public error: any
+  ){
+    super(message)
+  }
+}

package/src/match-lock-file/match-config/version-1/usage/validate-select/ensure-pieces-are-in-roster.ts

@@ -0,0 +1,61 @@
+
+import { RosterLockV1Config, PieceType, SelectedPiece } from "@roster-lock/types";
+
+export function ensurePiecesAreInRoster(
+  config: RosterLockV1Config,
+  pieceType: PieceType,
+  selections: Array<SelectedPiece>
+){
+  const requireConfig = new Set(config.engine.pieceDefinitions[pieceType].requires);
+  if(requireConfig.size !== config.engine.pieceDefinitions[pieceType].requires.length){
+    throw new Error(`${pieceType} requires has duplicate items`);
+  }
+  const roster = config.rosters[pieceType];
+  for(const piece of selections){
+    const rosterPiece = roster.find(p=>p.id === piece.id);
+    if(!rosterPiece){
+      throw new Error(`Piece ${piece.id} is not in the roster`);
+    }
+    const pieceRequiredKeys = Object.keys(piece.required);
+    if(pieceRequiredKeys.length !== requireConfig.size){
+      throw new Error(`Piece ${piece.id} has incorrect number of required keys`);
+    }
+    for(const requirePieceType of pieceRequiredKeys){
+      if(!requireConfig.has(requirePieceType)){
+        throw new Error(`Piece ${piece.id} is missing required piece type ${requirePieceType}`);
+      }
+      ensureCorrectMandatory(rosterPiece, requirePieceType, piece.required[requirePieceType].mandatory);
+      ensurePiecesAreInRoster(config, requirePieceType, piece.required[requirePieceType].mandatory);
+      ensureSelectionIsAllowed(rosterPiece, requirePieceType, piece.required[requirePieceType].selectable);
+      ensurePiecesAreInRoster(config, requirePieceType, piece.required[requirePieceType].selectable);
+    }
+  }
+}
+
+type RosterPiece = RosterLockV1Config["rosters"][string][number];
+function ensureCorrectMandatory(
+  rosterPiece: RosterPiece, requiredPieceType: string, mandatoryPieces: Array<SelectedPiece>
+){
+  const rosterMandatory = rosterPiece.requiredPieces[requiredPieceType];
+  if(!rosterMandatory) throw new Error(`Roster Piece ${rosterPiece.id} missing required ${requiredPieceType}`);
+  if(rosterMandatory.expected.length !== mandatoryPieces.length){
+    throw new Error(`Piece ${rosterPiece.id} has incorrect number of required pieces for ${requiredPieceType}`);
+  }
+  for(let i = 0; i < rosterMandatory.expected.length; i++){
+    const mandatoryId = rosterMandatory.expected[i];
+    const mandatoryPiece = mandatoryPieces[i];
+    if(mandatoryId !== mandatoryPiece.id){
+      throw new Error(`Piece ${rosterPiece.id} has incorrect required piece of ${requiredPieceType} at ${i}`);
+    }
+  }
+}
+
+function ensureSelectionIsAllowed(
+  rosterPiece: RosterPiece, requiredPieceType: string, selectedPieces: Array<SelectedPiece>
+){
+  const rosterMandatory = rosterPiece.requiredPieces[requiredPieceType];
+  if(!rosterMandatory) throw new Error(`Roster Piece ${rosterPiece.id} missing required ${requiredPieceType}`);
+  if(!rosterMandatory.selectable && selectedPieces.length > 0){
+    throw new Error(`Piece ${rosterPiece.id} does not allow custom selection for ${requiredPieceType}`);
+  }
+}

package/src/match-lock-file/match-config/version-1/usage/validate-select/handle-validation.ts

@@ -0,0 +1,54 @@
+
+import { RunUntrustedError } from "./constants";
+
+export async function handleValidationResult(
+  script: { src: string }, result: Promise<unknown>
+){
+  const isValid = await (async ()=>{
+    try {
+      return await result;
+    }catch(e){
+      throw new RunUntrustedError(
+        script.src, e instanceof Error ? e.message : String(e), e
+      );
+    }
+  })();
+  const errorStatus = normalizeError(isValid);
+  if(!errorStatus.passed){
+    throw new RunUntrustedError(
+      script.src, errorStatus.message, isValid
+    );
+  }
+}
+
+const INVALID_VALUE = "Invalid return type for validation";
+const FAILED_WITHOUT_MESSAGE = "Validation Failed";
+function normalizeError(validResult: unknown): (
+  | { passed: true }
+  | { passed: false, message: string }
+){
+  if(typeof validResult === "boolean"){
+    if(validResult) return { passed: true };
+    return { passed: false, message: FAILED_WITHOUT_MESSAGE };
+  }
+  if(Array.isArray(validResult)){
+    const [passed, reason] = validResult;
+    if(typeof passed !== "boolean"){
+      return { passed: false, message: INVALID_VALUE };
+    }
+    if(passed) return { passed: true };
+    return {
+      passed: false,
+      message: typeof reason === "string" ? reason : FAILED_WITHOUT_MESSAGE,
+    };
+  }
+  if(typeof validResult === "string"){
+    return {
+      passed: false,
+      message: validResult
+    };
+  }
+  if(validResult === null || validResult === void 0) return { passed: true };
+  return { passed: false, message: INVALID_VALUE };
+}
+