@roster-lock/shared 0.1.0

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@roster-lock/shared",
+  "version": "0.1.0",
+  "description": "Shared utilities, variables, etc between client and server",
+  "keywords": [
+    "roster-lock",
+    "game"
+  ],
+  "homepage": "https://github.com/formula1/roster-lock#readme",
+  "bugs": {
+    "url": "https://github.com/formula1/roster-lock/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/formula1/roster-lock.git",
+    "directory": "core/shared"
+  },
+  "license": "JSON",
+  "author": "Sam Tobia",
+  "main": "dist/index.js",
+  "types": "src/index.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/is-glob": "^4.0.4",
+    "@types/magnet-uri": "^5.1.5",
+    "@types/micromatch": "^4.0.9",
+    "@types/node": "^22.14.1",
+    "rimraf": "^6.0.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.5"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "cids": "^1.1.9",
+    "is-glob": "^4.0.3",
+    "json-diff-ts": "^4.8.2",
+    "magnet-uri": "^7.0.7",
+    "micromatch": "^4.0.8",
+    "runtypes": "^7.0.4",
+    "@roster-lock/types": "1.0.0",
+    "@roster-lock/utils": "1.0.0"
+  },
+  "scripts": {
+    "test": "vitest run tests/",
+    "build": "rimraf ./dist && tsc"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+
+export * from "./match-lock-file/config-types";
+export * from "./match-lock-file";

package/src/match-lock-file/config-types.ts

@@ -0,0 +1,10 @@
+
+export type UserId = string;
+export type CollectionId = string;
+
+export type PieceType = string;
+export type PieceId = string;
+
+export type AssetType = string;
+export type AssetId = string;
+

package/src/match-lock-file/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./match-config";
+export * from "./util-types/json-schema";
+

package/src/match-lock-file/match-config/index.ts

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

package/src/match-lock-file/match-config/version-0/pieces/caster-runtypes/index.ts

@@ -0,0 +1,99 @@
+import {
+  DateTimeCaster,
+  SemVerCaster,
+  Sha256Caster,
+  URLTypeCaster,
+  MagnetURICaster,
+  CountCaster,
+} from "./util-casters";
+
+import {
+  Record as CastRecord,
+  Object as CastObject,
+  Array as CastArray,
+  Tuple as CastTuple,
+  Literal,
+  Union as CastUnion,
+  String as CastString,
+} from "runtypes"
+
+import {
+  MatchLockResolvable,
+  MatchLockAsset,
+  MatchLockPublishPiece,
+  MatchLockScanPiece,
+} from "../types";
+
+
+const OwnableIdentificationCaster = {
+  name: CastString,
+  author: CastString,
+  published: DateTimeCaster,
+  preview: CastObject({
+    image: URLTypeCaster,
+    url: URLTypeCaster,
+  }),
+  sha256: Sha256Caster,
+  signature: CastString,
+  signatureVerificationUrl: URLTypeCaster,
+};
+
+const ResolvableCaster = CastUnion(
+  CastObject({
+    type: Literal("http"),
+    url: URLTypeCaster,
+  }),
+  CastObject({
+    type: Literal("torrent"),
+    uri: MagnetURICaster,
+  }),
+  CastObject({
+    type: Literal("git"),
+    url: URLTypeCaster,
+    ref: CastString.optional(),
+  }),
+).conform<MatchLockResolvable>();
+
+import { validatePathVariableName } from "../../../version-1/engine";
+import { validatePathVariableValue } from "../validate/definition/pathVariables";
+const AssetScanCaster = {
+  pieceDefinition: CastString,
+  version: CastObject({
+    logic: Sha256Caster,
+    media: Sha256Caster,
+  }),
+  pathVariables: CastRecord(
+    CastString.withConstraint((variableName)=>{
+      try {
+        validatePathVariableName(variableName);
+        return true;
+      }catch(e){
+        return (e as Error).message;
+      }
+    }),
+    CastString.withConstraint((variableValue)=>{
+      try {
+        validatePathVariableValue(variableValue);
+        return true;
+      }catch(e){
+        return (e as Error).message;
+      }
+    })
+  ),
+  assets: CastRecord(CastString, CastObject({
+    assetType: CastString,
+    sha256: Sha256Caster,
+    sizeBytes: CountCaster,
+  })),
+}
+
+export const MatchLockPublishPieceCaster = CastObject({
+  ...OwnableIdentificationCaster,
+  ...AssetScanCaster,
+
+  sources: CastArray(ResolvableCaster),
+}).conform<MatchLockPublishPiece>();
+
+export const MatchLockScanPieceCaster = (
+  CastObject(AssetScanCaster).conform<MatchLockScanPiece>()
+);

package/src/match-lock-file/match-config/version-0/pieces/caster-runtypes/util-casters.ts

@@ -0,0 +1,155 @@
+import {
+  String as CastString,
+  Number as CastNumber,
+  Boolean as CastBoolean,
+  Union as CastUnion,
+  Literal as CastLiteral,
+} from "runtypes";
+
+export type DateTime = string;
+export function validateDateTime(value: string){
+  if(!Date.parse(value)) throw new Error(`${value} is not a valid date`);
+}
+export const DateTimeCaster = CastString.withConstraint(value => {
+  try {
+    validateDateTime(value);
+    return true;
+  }catch(e){
+    return (e as Error).message;
+  }
+});
+
+export type SemVer = string;
+export function validateSemver(value: string){
+  // 1. split on dots
+  const parts = value.split(".");
+  if (parts.length !== 3) {
+    throw new Error("SemVer must have three numeric parts separated by `.`");
+  }
+
+  for (const part of parts) {
+    // 2. non‑empty
+    if (part.length === 0) {
+      throw new Error("SemVer parts may not be empty");
+    }
+    // 3. no leading zero (except “0” itself)
+    if (part.length > 1 && part[0] === "0") {
+      throw new Error(`Invalid leading zero in part “${part}”`);
+    }
+    // 4. all digits
+    if (!/^[0-9]+$/.test(part)) {
+      throw new Error(`Non-numeric SemVer part: “${part}”`);
+    }
+  }
+}
+export const SemVerCaster = CastString.withConstraint((value) => {
+  try {
+    validateSemver(value);
+    return true;
+  }catch(e){
+    return (e as Error).message;
+  }
+});;
+
+export type Sha256 = string;
+export function validateSha256(value: string){
+  // Must be exactly 64 hex chars (0–9, a–f, case‑insensitive)
+  if (!/^[0-9a-f]{64}$/i.test(value)) {
+    throw new Error(`${value} is not a valid SHA-256 (64-char hex)`);
+  }
+}
+export const Sha256Caster = CastString.withConstraint(value => {
+  try {
+    validateSha256(value);
+    return true;
+  }catch(e){
+    return (e as Error).message;
+  }
+});
+
+
+/*
+export async function createSHA256Hash(data: string){
+  const encoder = new TextEncoder();
+  const dataBuffer = encoder.encode(data);
+  const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+}
+*/
+
+export type URLType = string;
+export function validateURL(value: string){
+  if(!URL.canParse(value)) throw new Error(`${value} is not a valid URL`);
+}
+export const URLTypeCaster = CastString.withConstraint(value => {
+  try {
+    validateURL(value);
+    return true;
+  }catch(e){
+    return (e as Error).message;
+  }
+});
+
+
+import parseMagnet from "magnet-uri";
+export type MagnetUri = string;
+export function validateMagnetURI(value: string){
+  try {
+    const parsed = parseMagnet(value);
+    if(!parsed.infoHash) throw new Error("Magnet URI parsed but missing infoHash");
+  } catch (err: any) {
+    throw new Error(`Invalid Magnet URI: ${err.message}`);
+  }
+}
+export const MagnetURICaster = CastString.withConstraint(value => {
+  try {
+    validateMagnetURI(value);
+    return true;
+  } catch (e) {
+    return (e as Error).message;
+  }
+});
+
+export type Count = number;
+export const CountCaster = CastNumber.withConstraint(value => {
+  if(value < 0) return `${value} is not a valid count`;
+  return true;
+});
+
+
+export type PublicKey = string;
+export type SignedContent = string;
+
+
+export type FilePath = string;
+export function parseFilePath(filepath: string){
+  if(filepath.length === 0){
+    throw new Error("Filepath is empty");
+  }
+  if(filepath[0] !== "/"){
+    throw new Error("Filepath expected to start with \"/\"");
+  }
+  const dirParts = filepath.split("/");
+  const file = dirParts.pop();
+  if(!file){
+    throw new Error("Filepath expected to end with a file");
+  }
+  const fileParts = file.split(".")
+  const extension = fileParts.pop();
+  if(!extension){
+    throw new Error("Filepath expected to end with a file extension");
+  }
+  return {
+    dir: dirParts.join("/"),
+    filename: fileParts.join("."),
+    extension,
+  };
+}
+
+export const JSONPrimitiveCaster = CastUnion(
+  CastString,
+  CastNumber,
+  CastBoolean,
+  CastLiteral(null),
+);

package/src/match-lock-file/match-config/version-0/pieces/index.ts

@@ -0,0 +1,3 @@
+
+export * from "./types"
+export * from "./caster-runtypes";

package/src/match-lock-file/match-config/version-0/pieces/types.ts

@@ -0,0 +1,49 @@
+
+import {
+  PieceType,
+} from "../../../config-types";
+import {
+  DateTime,
+  Sha256,
+  URLType,
+  MagnetUri,
+  Count,
+  FilePath,
+  SignedContent,
+} from "./caster-runtypes/util-casters";
+
+export type MatchLockResolvable = (
+  | { type: "http"; url: URLType }
+  | { type: "torrent"; uri: MagnetUri }
+  | { type: "git"; url: URLType; ref?: string }
+);
+
+
+export type MatchLockAsset = {
+  assetType: string,
+  sha256: Sha256,
+  sizeBytes: Count,
+};
+
+export type MatchLockPublishPiece = {
+  name: string,
+  author: string,
+
+  preview: {
+    image: URLType,
+    url: URLType,
+  },
+  sources: MatchLockResolvable[],
+
+} & MatchLockScanPiece
+
+
+export type MatchLockScanPiece = {
+  pieceDefinition: PieceType,
+  version: {
+    logic: Sha256,
+    media: Sha256,
+  }
+  pathVariables: Record<string, string>,
+  assets: Record<FilePath, MatchLockAsset>,
+}

package/src/match-lock-file/match-config/version-0/pieces/validate/definition/assetCount.ts

@@ -0,0 +1,33 @@
+import { MatchLockEngineConfig } from "../../../engine";
+
+type ErrorInfo = {
+  pieceId: string,
+  assetType: string,
+}
+
+type AssetConfig = MatchLockEngineConfig["pieceDefinitions"][string]["assets"][0];
+
+export function validateAssetCount(
+  assetConfig: AssetConfig, assetCount: number, errorInfo: ErrorInfo
+){
+  const expectedCount = assetConfig.count;
+  if(!Array.isArray(expectedCount)){
+    if(expectedCount === "*"){
+      return;
+    }
+    if(assetCount !== expectedCount){
+      throw new Error(`Piece ${errorInfo.pieceId} has incorrect number of assets for ${errorInfo.assetType} expected ${expectedCount} but got ${assetCount}`);
+    }
+    return;
+  }
+  const [min, max] = expectedCount;
+  if(assetCount < min){
+    throw new Error(`Piece ${errorInfo.pieceId} has less assets for ${errorInfo.assetType} then minimum ${min}`);
+  }
+  if(max === "*"){
+    return;
+  }
+  if(assetCount > max){
+    throw new Error(`Piece ${errorInfo.pieceId} has more assets for ${errorInfo.assetType} than maximum ${max}`);
+  }
+}

package/src/match-lock-file/match-config/version-0/pieces/validate/definition/assetType.ts

@@ -0,0 +1,22 @@
+import { parseFilePath } from "../../../../util-types/runtypes";
+import { MatchLockEngineConfig } from "../../../engine";
+import { MatchLockScanPiece } from "../../version-0/types";
+
+export function validateAssetType(
+  pieceConfig: MatchLockEngineConfig["pieceDefinitions"][string],
+  pieceId: string,
+  filePath: string,
+  assetInfo: MatchLockScanPiece["assets"][string]
+){
+  const file = parseFilePath(filePath);
+  const assetType = file.extension.toLowerCase();
+  if(!(assetType in pieceConfig.assets)){
+    throw new Error(`Piece ${pieceId} references asset ${assetType} which is not in the piece definition`);
+  }
+  const assetTypeFromDef = assetInfo.assetType;
+  if(assetTypeFromDef !== assetType){
+    throw new Error(`Piece ${pieceId} references asset at ${filePath} which is of type ${assetTypeFromDef} but the piece is of type ${assetType}`);
+  }
+  return assetType;
+}
+

package/src/match-lock-file/match-config/version-0/pieces/validate/definition/index.ts

@@ -0,0 +1,30 @@
+import { MatchLockEngineConfig } from "../../../engine";
+import { MatchLockScanPiece } from "../../version-0/types";
+
+import { getPieceId } from "../../utils";
+import { validatePathVariableValues } from "./pathVariables";
+import { validateAssetType } from "./assetType";
+import { validateAssetCount } from "./assetCount";
+
+export * from "./pathVariables";
+
+export function validatePieceMatchesEngineDefinition(
+  engine: MatchLockEngineConfig, piece: MatchLockScanPiece
+){
+  const pieceId = getPieceId(piece);
+  const pieceConfig = engine.pieceDefinitions[piece.pieceDefinition];
+  if(!pieceConfig){
+    throw new Error(`Piece ${pieceId} is of type ${piece.pieceDefinition} which is not in the engine config`);
+  }
+  validatePathVariableValues(pieceConfig, piece.pathVariables);
+  const counts = new Map<string, number>();
+  for(const [filePath, assetInfo] of Object.entries(piece.assets)){
+    const assetType = validateAssetType(pieceConfig, pieceId, filePath, assetInfo);
+    counts.set(assetType, (counts.get(assetType) ?? 0) + 1);
+  }
+  for(const [assetType, assetConfig] of Object.entries(pieceConfig.assets)){
+    const assetCount = counts.get(assetType) ?? 0;
+    validateAssetCount(assetConfig, assetCount, { pieceId: pieceId, assetType });
+  }
+}
+

package/src/match-lock-file/match-config/version-0/pieces/validate/definition/pathVariables.ts

@@ -0,0 +1,39 @@
+import { MatchLockEngineConfig } from "../../../../version-1/engine";
+import { PATH_VARIABLE_VALUE_VALIDATION } from "../../../../version-1/engine/validate/piece/assets/glob/pathvariables";
+
+export function validateAllExpectedPathVariableNamesSet(
+  pathVariableValues: pathVariables
+  pieceConfig: MatchLockEngineConfig["pieceDefinitions"][string],
+){
+  for(const variableName of pieceConfig.pathVariables){
+    if(!(variableName in pathVariableValues)){
+      throw new Error(`Piece is missing value for path variable ${variableName}`);
+    }
+  }
+}
+
+export function validatePathVariableValue(
+  variableValue: string,
+){
+  if (variableValue.length < PATH_VARIABLE_VALUE_VALIDATION.minLength) {
+    throw new Error(`Path variable value is too short`);
+  }
+  
+  if (variableValue.length > PATH_VARIABLE_VALUE_VALIDATION.maxLength) {
+    throw new Error(`Path variable value is too long`);
+  }
+  
+  const charsetRegex = new RegExp(`^[${PATH_VARIABLE_VALUE_VALIDATION.charset}]+$`);
+  if (!charsetRegex.test(variableValue)) {
+    throw new Error(`Path variable value contains invalid characters`);
+  }
+}
+
+export function validatePathVariableNameIsExpected(
+  variableName: string,
+  pieceConfig: MatchLockEngineConfig["pieceDefinitions"][string],
+){
+  if(!pieceConfig.pathVariables.includes(variableName)){
+    throw new Error(`Piece does not have path variable ${variableName}`);
+  }
+}

package/src/match-lock-file/match-config/version-0/pieces/validate/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./definition";
+export * from "./version";
+export * from "./sha";

package/src/match-lock-file/match-config/version-0/pieces/validate/sha.ts

@@ -0,0 +1,23 @@
+import { canonicalJSONStringify } from "../../../../../utils/JSON";
+import { MatchLockPublishPiece } from "../types";
+import { createSHA256Hash } from "../../../../util-types/runtypes";
+
+
+export async function validatePublishPieceSha(piece: MatchLockPublishPiece){
+  const predictableString = canonicalJSONStringify({
+    name: piece.name,
+    author: piece.author,
+    published: piece.published,
+    preview: piece.preview,
+    sources: piece.sources,
+
+    pieceDefinition: piece.pieceDefinition,
+    version: piece.version,
+    assets: piece.assets,
+  });
+  const sha = await createSHA256Hash(predictableString);
+
+  if(sha !== piece.sha256){
+    throw new Error("Restriction's sha isn't equal to the expected")
+  };
+}

package/src/match-lock-file/match-config/version-0/pieces/validate/version.ts

@@ -0,0 +1,66 @@
+import { MatchLockEngineConfig, AssetClassification } from "../../engine";
+import { MatchLockScanPiece } from "../version-0/types";
+
+import { getPieceId } from "../utils";
+
+export function validatePieceVersion(
+  engine: MatchLockEngineConfig, piece: MatchLockScanPiece
+){
+  const pieceId = getPieceId(piece);
+  const logicSha = getCombinedAssetSha(engine, piece, "logic");
+  if(logicSha !== piece.version.logic){
+    throw new Error(`Logic SHA Mismatch for ${pieceId}`);
+  }
+}
+
+import { canonicalJSONStringify } from "../../../../utils/JSON";
+import { createHash } from "node:crypto";
+function getCombinedAssetSha(
+  engine: MatchLockEngineConfig, piece: MatchLockScanPiece, type: AssetClassification
+){
+  const pieceId = getPieceId(piece);
+  const assetShas: Array<string> = [];
+  for(const [filepath, asset] of Object.entries(piece.assets)){
+    const assetByFilename = getAssetByGlob(
+      engine.pieceDefinitions[piece.pieceDefinition], piece.pathVariables, filepath
+    );
+    const assetByName = getAssetByName(engine.pieceDefinitions[piece.pieceDefinition], assetByFilename.name);
+    if(assetByFilename.name !== assetByName.name){
+      throw new Error(`Asset Name Mismatch for ${pieceId}`);
+    }
+    if(assetByFilename.classification !== type) continue;
+    assetShas.push(canonicalJSONStringify(asset));
+  }
+
+  if(assetShas.length === 0) {
+    return ""
+  }
+
+  // 2) Sort
+  assetShas.sort();
+
+  // 3) Concatenate
+  const concatenated = Buffer.from(assetShas.join(""), "hex");
+
+  // 4) Hash it
+  return createHash("sha256").update(concatenated).digest("hex");
+}
+
+import { getMatchingAssetsForFile } from "../../engine";
+function getAssetByGlob(
+  pieceDefinition: MatchLockEngineConfig["pieceDefinitions"][string],
+  pathVariables: Record<string, string>,
+  filepath: string
+){
+  const assets = getMatchingAssetsForFile(pieceDefinition, pathVariables, filepath);
+  if(assets.length === 0){
+    throw new Error(`No matching asset for ${filepath}`);
+  }
+  return assets[0];
+}
+
+function getAssetByName(pieceDefinition: MatchLockEngineConfig["pieceDefinitions"][string], name: string){
+  const config = pieceDefinition.assets.find((a) => a.name === name);
+  if(!config) throw new Error(`No matching asset for ${name}`);
+  return config;
+}

package/src/match-lock-file/match-config/version-0/restriction/casters.ts

@@ -0,0 +1,52 @@
+
+import {
+  DateTimeCaster,
+  SemVerCaster,
+  Sha256Caster,
+  URLTypeCaster,
+  MagnetURICaster,
+  CountCaster,
+} from "../pieces/caster-runtypes/util-casters";
+
+import {
+  Record as CastRecord,
+  Object as CastObject,
+  Array as CastArray,
+  Tuple as CastTuple,
+  Literal,
+  Union as CastUnion,
+  String as CastString,
+} from "runtypes"
+
+import { MatchLockRestrictionConfig } from "./types";
+
+
+import { MatchLockEngineCaster } from "../../engine";
+import { MatchLockPublishPieceCaster } from "../../piece";
+import { MatchLockSelectionConfigCaster } from "../../selection";
+
+export const MatchLockRestrictionConfigCaster = CastObject({
+  name: CastString,
+  version: SemVerCaster,
+  sha256: Sha256Caster,
+
+  published: DateTimeCaster,
+
+  signature: CastString,
+  signatureVerificationUrl: URLTypeCaster,
+
+  engine: MatchLockEngineCaster,
+
+  pieces: CastRecord(CastString, CastObject({
+    selectionConfig: MatchLockSelectionConfigCaster,
+    pieceDefinition: CastString,
+    pieces: CastArray(
+      CastObject({
+        ...MatchLockPublishPieceCaster.fields,
+        id: CastString,
+        requiredPieces: CastRecord(CastString, CastArray(CastString)).optional(),
+      })
+    ),
+  }))
+}).conform<MatchLockRestrictionConfig>();
+

package/src/match-lock-file/match-config/version-0/restriction/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./types";
+export * from "./casters";
+export * from "./validate"