@roster-lock/shared 0.1.0

package/src/match-lock-file/match-config/version-1/lock/piece-meta/validate/index.ts

@@ -0,0 +1,114 @@
+import Ajv, { JSONSchemaType } from "ajv";
+import {
+  RosterLockV1Config, PieceType, JSONShallowObject, SelectionPieceMeta
+} from "@roster-lock/types";
+import { cloneJSON } from "@roster-lock/utils";
+
+export function validatePieceMeta(
+  config: RosterLockV1Config
+){
+  for(const [pieceType, meta] of Object.entries(config.pieceMeta)){
+    validatePieceMetaConfig(meta, pieceType, config);
+  }
+}
+
+export function validatePieceMetaConfig(
+  meta: SelectionPieceMeta<any>,
+  pieceType: PieceType,
+  { engine, rosters }: RosterLockV1Config
+){
+  const pieceDefinition = engine.pieceDefinitions[pieceType];
+  if(!pieceDefinition){
+    throw new Error(`Piece type ${pieceType} is not defined in engine`);
+  }
+  const roster = rosters[pieceType];
+  if(!roster){
+    throw new Error(`Piece type ${pieceType} is not defined in roster`);
+  }
+
+  validateMetaDefaultValue(meta.schema, meta.defaultMeta);
+
+  for(const [pieceId, pieceValue] of Object.entries(meta.values)){
+    validateMetaForPiece(meta.schema, pieceId, pieceValue, roster);
+  }
+}
+
+function simpleSchemaToJSONSchemaType(schema: SelectionPieceMeta<any>["schema"]): JSONSchemaType<JSONShallowObject> {
+  const required: Array<string> = [];
+  const properties: Record<string, JSONSchemaType<(
+    | boolean | number | string
+    | Array<boolean> | Array<number> | Array<string>
+  )>> = {};
+  for(const [key, value] of Object.entries(schema)){
+    required.push(key);
+    switch(value){
+      case "boolean":
+        properties[key] = { type: "boolean" };
+        break;
+      case "number":
+        properties[key] = { type: "number" };
+        break;
+      case "string":
+        properties[key] = { type: "string" };
+        break;
+      case "boolean[]":
+        properties[key] = { type: "array", items: { type: "boolean" } };
+        break;
+      case "number[]":
+        properties[key] = { type: "array", items: { type: "number" } };
+        break;
+      case "string[]":
+        properties[key] = { type: "array", items: { type: "string" } };
+        break;
+    }
+  }
+
+  const jsonSchema: JSONSchemaType<JSONShallowObject> = {
+    type: "object",
+    required,
+    additionalProperties: false,
+    properties,
+  };
+
+  return jsonSchema;
+}
+
+export function validateMetaDefaultValue(
+  simpleSchema: SelectionPieceMeta<any>["schema"],
+  meta: SelectionPieceMeta<any>["defaultMeta"]
+){
+  const metaSchema = simpleSchemaToJSONSchemaType(simpleSchema);
+  const defaultMeta = Object.keys(meta);
+  if(defaultMeta.length !== metaSchema.required.length){
+    throw new Error(`Piece meta default meta must have all required keys`);
+  }
+  for(const key of metaSchema.required){
+    if(!defaultMeta.includes(key)){
+      throw new Error(`Piece meta default meta must have all required keys`);
+    }
+  }
+  const ajv = new Ajv();
+  if(!ajv.validate(metaSchema, meta)){
+    throw new Error(`Piece meta default meta does not match schema`);
+  }
+}
+
+export function validateMetaForPiece(
+  simpleSchema: SelectionPieceMeta<any>["schema"],
+  pieceId: string,
+  meta: SelectionPieceMeta<any>["values"][string],
+  roster: RosterLockV1Config["rosters"][string]
+){
+  const metaSchema = simpleSchemaToJSONSchemaType(simpleSchema);
+  const piece = roster.find(p=>p.id === pieceId);
+  if(!piece){
+    throw new Error(`Piece meta references piece ${pieceId} which is not in the roster`);
+  }
+
+  const cloned = cloneJSON(metaSchema);
+  cloned.required = [];
+  const ajv = new Ajv();
+  if(!ajv.validate(cloned, meta)){
+    throw new Error(`Piece meta does not match schema`);
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/rosters/caster-json-schema/downloadableSources.ts

@@ -0,0 +1,25 @@
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockPiece = RosterLockV1Config["rosters"][string][number];
+import { defineKeyword } from "../../../../../util-types/json-schema";
+
+import {
+  validateDownloadableSourceList
+} from "../validate";
+
+export const downloadableSourceListSchemaValidator = defineKeyword({
+  keyword: "rosterDownloadableSourceList",
+  type: "array",
+  validate: validateDownloadableSourceList
+});
+
+
+export const downloadableSourcesSchema: JSONSchemaType<RosterLockPiece["downloadSources"]> = {
+  type: "array",
+  [downloadableSourceListSchemaValidator.keyword]: true,
+  items: {
+    type: "string",
+  },
+};
+
+

package/src/match-lock-file/match-config/version-1/lock/rosters/caster-json-schema/human.ts

@@ -0,0 +1,33 @@
+import { JSONSchemaType } from "ajv"
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockPiece = RosterLockV1Config["rosters"][string][number];
+import { defineKeyword } from "../../../../../util-types/json-schema";
+
+
+import { validateURL } from "../validate";
+export const urlSchemaValidator = defineKeyword({
+  keyword: "URL",
+  type: "string",
+  validate: validateURL
+});
+
+import { validateFriendlyString } from "../validate/human";
+export const friendlyStringSchemaValidator = defineKeyword({
+  keyword: "friendlyString",
+  type: "string",
+  validate: validateFriendlyString
+});
+
+
+export const humanInfoSchema: JSONSchemaType<RosterLockPiece["humanInfo"]> = {
+  type: "object",
+  additionalProperties: false,
+  required: ["name", "author", "url"],
+  properties: {
+    name: { type: "string", [friendlyStringSchemaValidator.keyword]: true },
+    author: { type: "string", [friendlyStringSchemaValidator.keyword]: true },
+    url: { type: "string", [urlSchemaValidator.keyword]: true },
+    image: { type: "string", [urlSchemaValidator.keyword]: true, nullable: true },
+  },
+}
+

package/src/match-lock-file/match-config/version-1/lock/rosters/caster-json-schema/id.ts

@@ -0,0 +1,33 @@
+import { JSONSchemaType } from "ajv";
+
+import { defineKeyword } from "../../../../../util-types/json-schema";
+import { validatePieceId, validatePieceIdUniqueness } from "../validate";
+import { RosterLockV1Config } from "@roster-lock/types";
+
+
+export const idSchemaValidator = defineKeyword({
+  keyword: "rosterPieceId",
+  type: "string",
+  validate: validatePieceId
+});
+
+export const idUniquenessSchemaValidator = defineKeyword({
+  keyword: "rosterPieceIdUniqueness",
+  type: "string",
+  validate: function (id: string, { rosters }: RosterLockV1Config, path){
+    // config/rosters/pieceType/pieceIndex/id
+    const pathParts = path.split("/");
+    const pieceIndex = Number(pathParts.at(-2));
+    if(Number.isNaN(pieceIndex)) throw new Error(`Invalid path: pieceIndex ${pieceIndex} is not a number`);
+    const pieceType = pathParts.at(-3);
+    if(!pieceType) throw new Error("Invalid path: no pieceType");
+    const pieceList = rosters[pieceType];
+    validatePieceIdUniqueness(id, pieceIndex, pieceList);
+  }
+});
+
+export const idSchema: JSONSchemaType<string> = {
+  type: "string",
+  [idSchemaValidator.keyword]: true,
+  [idUniquenessSchemaValidator.keyword]: true,
+}

package/src/match-lock-file/match-config/version-1/lock/rosters/caster-json-schema/index.ts

@@ -0,0 +1,103 @@
+import { JSONSchemaType } from "ajv";
+import { defineKeyword } from "../../../../../util-types/json-schema";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockPiece = RosterLockV1Config["rosters"][string][number];
+
+import { idSchema, idUniquenessSchemaValidator, idSchemaValidator } from "./id";
+import { versionSchema, sha256SchemaValidator } from "./version";
+import { humanInfoSchema, urlSchemaValidator, friendlyStringSchemaValidator } from "./human";
+import {
+  downloadableSourcesSchema,
+  downloadableSourceListSchemaValidator,
+} from "./downloadableSources";
+import {
+  pathVariablesSchema,
+  pathVariableNameSchemaValidator,
+  pathVariableValueSchemaValidator,
+  allPathVariableNameSetSchemaValidator,
+} from "./pathVariables";
+import {
+  requiredPiecesSchema,
+  allRequiredPieceTypesSetSchemaValidator,
+  requiredPieceValueSchemaValidator,
+  requiredPieceTypeSchemaValidator,
+} from "./requiresPieces";
+
+
+const pieceTypeInEngineSchemaValidator = defineKeyword({
+  keyword: "rosterPieceTypeInEngine",
+  type: "object",
+  validate: function (piece: RosterLockPiece, { engine }: RosterLockV1Config, path){
+    // config/pieces/pieceType/pieceIndex
+    const pieceType = path.split("/").at(-2);
+    if(!pieceType) throw new Error("Invalid path");
+    validatePieceInEngine(pieceType, engine);
+  }
+});
+
+export const rosterLockPiece: JSONSchemaType<RosterLockPiece> = {
+  type: "object",
+  [pieceTypeInEngineSchemaValidator.keyword]: true,
+  required: ["id", "version", "humanInfo", "downloadSources", "pathVariables", "requiredPieces"],
+  additionalProperties: false,
+  properties: {
+    id: idSchema,
+    version: versionSchema,
+    humanInfo: humanInfoSchema,
+    downloadSources: downloadableSourcesSchema,
+    pathVariables: pathVariablesSchema,
+    requiredPieces: requiredPiecesSchema,
+  },
+};
+
+
+import { validateAllEnginePiecesDefined, validatePieceInEngine } from "../validate";
+const allPieceTypesInEngineSchemaValidator = defineKeyword({
+  keyword: "allEnginePieceTypesInRoster",
+  type: "object",
+  validate: function (rosters: RosterLockV1Config["rosters"], { engine }: RosterLockV1Config, path){
+    validateAllEnginePiecesDefined(rosters, engine);
+  }
+});
+
+export const rostersSchema: JSONSchemaType<RosterLockV1Config["rosters"]> = {
+  type: "object",
+  [allPieceTypesInEngineSchemaValidator.keyword]: true,
+  required: [],
+  additionalProperties: {
+    type: "array",
+    items: rosterLockPiece,
+  },
+};
+
+
+export const rosterKeywords = [
+  // Download Related
+  downloadableSourceListSchemaValidator,
+
+  // Human Related
+  urlSchemaValidator,
+  friendlyStringSchemaValidator,
+
+  // Id Related
+  idSchemaValidator,
+  idUniquenessSchemaValidator,
+
+  // Path Variable Related
+  pathVariableNameSchemaValidator,
+  pathVariableValueSchemaValidator,
+  allPathVariableNameSetSchemaValidator,
+
+  // Required Piece Related
+  allRequiredPieceTypesSetSchemaValidator,
+  requiredPieceValueSchemaValidator,
+  requiredPieceTypeSchemaValidator,
+
+  // Version Related
+  sha256SchemaValidator,
+
+
+  // Defined Here
+  allPieceTypesInEngineSchemaValidator,
+  pieceTypeInEngineSchemaValidator,
+];

package/src/match-lock-file/match-config/version-1/lock/rosters/caster-json-schema/pathVariables.ts

@@ -0,0 +1,59 @@
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockPiece = RosterLockV1Config["rosters"][string][number];
+import { defineKeyword } from "../../../../../util-types/json-schema";
+import {
+  validatePathVariableNameIsExpected,
+  validatePathVariableValue, 
+  validateAllExpectedPathVariableNamesSet,
+} from "../validate";
+
+export const pathVariableNameSchemaValidator = defineKeyword({
+  keyword: "rosterPathVariableName",
+  type: "string",
+  validate: function (pathVariableValue, { engine }: RosterLockV1Config, path){
+    const pathParts = path.split("/");
+    // config/pieces/pieceType/pieceIndex/pathVariables/variableName
+    const variableName = pathParts.at(-1);
+    if(!variableName)
+      throw new Error(`Invalid variable name path`);
+    const pieceType = pathParts.at(-4);
+    if(!pieceType)
+      throw new Error(`Invalid piece type path`);
+
+    const pieceDefinition = engine.pieceDefinitions[pieceType];
+    validatePathVariableNameIsExpected(variableName, pieceDefinition);
+  }
+});
+
+export const pathVariableValueSchemaValidator = defineKeyword({
+  keyword: "rosterPathVariableValue",
+  type: "string",
+  validate: function (pathVariableValue, { engine }: RosterLockV1Config, path){
+    validatePathVariableValue(pathVariableValue);
+  }
+});
+
+export const allPathVariableNameSetSchemaValidator = defineKeyword({
+  keyword: "rosterAllPathVariableNameSet",
+  type: "object",
+  validate: function (pathVariables, { engine }: RosterLockV1Config, path){
+    // config/pieces/pieceType/pieceIndex/pathVariables
+    const pieceType = path.split("/").at(-3);
+    if(!pieceType)
+      throw new Error(`Invalid piece type path`);
+    const pieceDefinition = engine.pieceDefinitions[pieceType];
+    validateAllExpectedPathVariableNamesSet(pathVariables, pieceDefinition);
+  }
+});
+
+export const pathVariablesSchema: JSONSchemaType<RosterLockPiece["pathVariables"]> = {
+  type: "object",
+  [allPathVariableNameSetSchemaValidator.keyword]: true,
+  required: [],
+  additionalProperties: {
+    type: "string",
+    [pathVariableNameSchemaValidator.keyword]: true,
+    [pathVariableValueSchemaValidator.keyword]: true,
+  },
+}

package/src/match-lock-file/match-config/version-1/lock/rosters/caster-json-schema/requiresPieces.ts

@@ -0,0 +1,71 @@
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockPiece = RosterLockV1Config["rosters"][string][number];
+import { defineKeyword } from "../../../../../util-types/json-schema";
+import {
+  validateAllExpectedRequiredPieceTypesSet,
+  validateRequiredPieceType,
+  validateRequiredPieceValue
+} from "../validate";
+
+export const allRequiredPieceTypesSetSchemaValidator = defineKeyword({
+  keyword: "rosterAllRequiredPieceTypesSet",
+  type: "object",
+  // config/pieces/pieceType/pieceIndex/requiredPieces
+  validate: function (requiredPieces, { engine }: RosterLockV1Config, path){
+    const pieceType = path.split("/").at(-3);
+    if(!pieceType) throw new Error("Invalid path");
+    const pieceDefinition = engine.pieceDefinitions[pieceType];
+    validateAllExpectedRequiredPieceTypesSet(requiredPieces, pieceDefinition);
+  }
+});
+
+export const requiredPieceValueSchemaValidator = defineKeyword({
+  keyword: "rosterRequiredPieceValue",
+  type: "string",
+  // rosters/pieceType/pieceIndex/requiredPieces/requiredPieceType/expected/index
+  validate: function (requiredPiece: string, { rosters }: RosterLockV1Config, path){
+    const pathParts = path.split("/");
+    pathParts.pop();
+    const pieceType = pathParts.at(-2);
+    if(!pieceType) throw new Error("Invalid path");
+    const pieceValues = rosters[pieceType];
+    validateRequiredPieceValue(pieceType, requiredPiece, pieceValues);
+  }
+});
+
+export const requiredPieceTypeSchemaValidator = defineKeyword({
+  keyword: "rosterRequiredPieceType",
+  type: "object",
+  // config/pieces/pieceType/pieceIndex/requiredPieces/pieceType
+  validate: function (requiredPiece: string, config: RosterLockV1Config, path){
+    const pathParts = path.split("/");
+    const pieceType = pathParts.at(-1);
+    if(!pieceType) throw new Error("Invalid path");
+
+    validateRequiredPieceType(pieceType, config);
+  }
+});
+
+
+export const requiredPiecesSchema: JSONSchemaType<RosterLockPiece["requiredPieces"]> = {
+  type: "object",
+  [allRequiredPieceTypesSetSchemaValidator.keyword]: true,
+  required: [],
+  additionalProperties: {
+    type: "object",
+    [requiredPieceTypeSchemaValidator.keyword]: true,
+    required: ["expected", "selectable"],
+    additionalProperties: false,
+    properties: {
+      expected: {
+        type: "array",
+        items: {
+          type: "string",
+          [requiredPieceValueSchemaValidator.keyword]: true,
+        },
+      },
+      selectable: { type: "boolean" },
+    },
+  }
+};

package/src/match-lock-file/match-config/version-1/lock/rosters/caster-json-schema/version.ts

@@ -0,0 +1,22 @@
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockPiece = RosterLockV1Config["rosters"][string][number];
+import { defineKeyword } from "../../../../../util-types/json-schema";
+
+import { validateSha256 } from "../validate";
+export const sha256SchemaValidator = defineKeyword({
+  keyword: "sha256",
+  type: "string",
+  validate: validateSha256
+});
+
+export const versionSchema: JSONSchemaType<RosterLockPiece["version"]> = {
+  type: "object",
+  additionalProperties: false,
+  required: ["logic", "media", "docs"],
+  properties: {
+    logic: { type: "string", [sha256SchemaValidator.keyword]: true },
+    media: { type: "string", [sha256SchemaValidator.keyword]: true },
+    docs: { type: "string", [sha256SchemaValidator.keyword]: true },
+  },
+}

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

@@ -0,0 +1,3 @@
+
+export * from "./validate";
+export * from "./caster-json-schema";

package/src/match-lock-file/match-config/version-1/lock/rosters/validate/downloadable-source.ts

@@ -0,0 +1,9 @@
+
+
+export function validateDownloadableSourceList(sources: Array<string>){
+  if(sources.length === 0)
+    throw new Error("Expecting at least 1 source");
+  if(new Set(sources).size !== sources.length)
+    throw new Error("Has duplicate sources");
+}
+

package/src/match-lock-file/match-config/version-1/lock/rosters/validate/human.ts

@@ -0,0 +1,22 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+import { validateURL } from "./utils";
+
+
+export function validateHumanInfo(
+  humanInfo: RosterLockV1Config["rosters"][string][0]["humanInfo"]
+){
+  validateFriendlyString(humanInfo.name);
+  validateFriendlyString(humanInfo.author);
+  validateURL(humanInfo.url);
+  if(humanInfo.image) validateURL(humanInfo.image);
+}
+
+export function validateFriendlyString(value: string){
+  if(!value.trim()) throw new Error("String is required");
+  if(value.length > 100) throw new Error("String is too long");
+  if(value.length < 3) throw new Error("String is too short");
+
+  if(value.includes('\0')) throw new Error("ID contains null character");
+  if(/[\x00-\x1F\x7F-\x9F]/.test(value)) throw new Error("ID contains control character");
+  if (/[\r\n\t\v\f]/.test(value)) throw new Error("ID contains whitespace character");
+}

package/src/match-lock-file/match-config/version-1/lock/rosters/validate/id.ts

@@ -0,0 +1,20 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+
+export function validatePieceId(id: string){
+  if(id.length === 0) throw new Error("ID is empty");
+  if(id.length > 128) throw new Error("ID is too long");
+  if(id !== id.trim()) throw new Error("ID contains a trailing or leading space");
+
+  if(id.includes('\0')) throw new Error("ID contains null character");
+  if(/[\x00-\x1F\x7F-\x9F]/.test(id)) throw new Error("ID contains control character");
+  if (/[\r\n\t\v\f]/.test(id)) throw new Error("ID contains whitespace character");
+}
+
+export function validatePieceIdUniqueness(
+  id: string, index: number, rosters: RosterLockV1Config["rosters"][string]
+){
+  for(let i = 0; i < rosters.length; i++){
+    if(i === index) continue;
+    if(rosters[i].id === id) throw new Error(`Duplicate ID ${id}`);
+  }
+}

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

@@ -0,0 +1,83 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+
+export * from "./id";
+export * from "./downloadable-source";
+export * from "./human";
+export * from "./path-variables";
+export * from "./required-pieces";
+export * from "./utils";
+export * from "./version";
+
+import { validateVersions, validateVersionUniqueness } from "./version";
+import { validateHumanInfo } from "./human";
+import {
+  validateDownloadableSourceList,
+} from "./downloadable-source";
+import {
+  validateAllExpectedPathVariableNamesSet,
+  validatePathVariableNameIsExpected,
+  validatePathVariableValue,
+} from "./path-variables";
+import {
+  validateAllExpectedRequiredPieceTypesSet,
+  validateRequiredPieceType,
+  validateRequiredPieceValue,
+} from "./required-pieces";
+import { validatePieceId, validatePieceIdUniqueness } from "./id";
+export function validateRosterLockPieces(
+  config: RosterLockV1Config
+){
+  const { engine, rosters } = config;
+  validateAllEnginePiecesDefined(rosters, engine);
+  for(const [pieceType, pieceList] of Object.entries(rosters)){
+    for(let i = 0; i < pieceList.length; i++){
+      const piece = pieceList[i];
+      validatePieceInEngine(pieceType, engine);
+      const pieceConfig = engine.pieceDefinitions[pieceType];
+
+      validatePieceId(piece.id);
+      validatePieceIdUniqueness(piece.id, i, pieceList);
+
+      validateVersions(piece.version);
+      validateVersionUniqueness(piece.version, i, pieceList);
+
+      validateHumanInfo(piece.humanInfo);
+      // Download Sources
+      validateDownloadableSourceList(piece.downloadSources);
+
+      // Path Variables
+      validateAllExpectedPathVariableNamesSet(piece.pathVariables, pieceConfig);
+      for(const [variableName, variableValue] of Object.entries(piece.pathVariables)){
+        validatePathVariableNameIsExpected(variableName, pieceConfig);
+        validatePathVariableValue(variableValue);
+      }
+
+      // Required Pieces
+      validateAllExpectedRequiredPieceTypesSet(piece.requiredPieces, pieceConfig);
+      for(const [requiredPieceType, requiredPiece] of Object.entries(piece.requiredPieces)){
+        validateRequiredPieceType(requiredPieceType, config);
+        for(const pieceSha of requiredPiece.expected){
+          validateRequiredPieceValue(requiredPieceType, pieceSha, rosters[requiredPieceType]);
+        }
+      }
+    }
+  }
+}
+
+export function validateAllEnginePiecesDefined(
+  rosters: RosterLockV1Config["rosters"], engine: RosterLockV1Config["engine"]
+){
+  for(const pieceType of Object.keys(engine.pieceDefinitions)){
+    if(!(pieceType in rosters)){
+      throw new Error(`Piece type ${pieceType} is defined in engine but not in roster`);
+    }
+  }
+}
+
+export function validatePieceInEngine(
+  pieceType: string, engine: RosterLockV1Config["engine"]
+){
+  if(!(pieceType in engine.pieceDefinitions)){
+    throw new Error(`Piece type ${pieceType} is not defined in engine`);
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/rosters/validate/path-variables.ts

@@ -0,0 +1,40 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+import { PATH_VARIABLE_VALUE_VALIDATION } from "../../engine/validate/piece/assets/glob/pathvariables";
+type RosterLockPiece = RosterLockV1Config["rosters"][string][number];
+
+export function validateAllExpectedPathVariableNamesSet(
+  pathVariableValues: RosterLockPiece["pathVariables"],
+  pieceConfig: RosterLockV1Config["engine"]["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 validatePathVariableNameIsExpected(
+  variableName: string,
+  pieceConfig: RosterLockV1Config["engine"]["pieceDefinitions"][string],
+){
+  if(!pieceConfig.pathVariables.includes(variableName)){
+    throw new Error(`Piece does not have 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`);
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/rosters/validate/required-pieces.ts

@@ -0,0 +1,30 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+
+export function validateAllExpectedRequiredPieceTypesSet(
+  requiredPieces: RosterLockV1Config["rosters"][string][0]["requiredPieces"],
+  pieceConfig: RosterLockV1Config["engine"]["pieceDefinitions"][string],
+){
+  for(const requiredPieceType of pieceConfig.requires){
+    if(!(requiredPieceType in requiredPieces)){
+      throw new Error(`Piece is missing required piece type ${requiredPieceType}`);
+    }
+  }
+}
+
+export function validateRequiredPieceType(
+  pieceType: string, { engine, rosters }: RosterLockV1Config
+){
+  const pieceDefinition = engine.pieceDefinitions[pieceType];
+  if(!pieceDefinition)
+    throw new Error(`Piece type ${pieceType} is not defined in engine`);
+  if(!(pieceType in rosters))
+    throw new Error(`Piece type ${pieceType} is not defined in roster`);
+}
+
+export function validateRequiredPieceValue(
+  pieceType: string, pieceId: string, roster: RosterLockV1Config["rosters"][string]
+){
+  if(!roster.find((p) => p.id === pieceId)){
+    throw new Error(`Piece type ${pieceType} does not have the required piece with id ${pieceId}`);
+  }
+}