@roster-lock/shared 0.1.0

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

@@ -0,0 +1,17 @@
+
+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)) return;
+  throw new Error(`${value} is not a valid SHA-256 (64-char hex)`);
+}
+
+export function validateURL(value: string){
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`${value} is not a valid URL`);
+  }
+  if(url.protocol === "http:" && url.hostname === "localhost") return;
+  if(!["https:"].includes(url.protocol)) throw new Error(`${value} is not a valid https`);
+}

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

@@ -0,0 +1,22 @@
+
+import { RosterLockV1Config } from "@roster-lock/types";
+
+import { validateSha256 } from "./utils";
+
+type PieceVersion = RosterLockV1Config["rosters"][string][0]["version"];
+export function validateVersions(
+  versions: PieceVersion
+){
+  validateSha256(versions.logic);
+  validateSha256(versions.media);
+  validateSha256(versions.docs);
+}
+
+export function validateVersionUniqueness(
+  versions: PieceVersion, index: number, rosters: RosterLockV1Config["rosters"][string]
+){
+  for(let i = 0; i < rosters.length; i++){
+    if(i === index) continue;
+    if(rosters[i].version.logic === versions.logic) throw new Error(`Duplicate Logic Version ${versions.logic}`);
+  }
+}

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

@@ -0,0 +1,53 @@
+import { JSONSchemaType } from "ajv";
+
+
+import { RosterLockV1Config } from "@roster-lock/types";
+
+import { preselectedSelectionSchema } from "./selection-types/preselected";
+import { normalSelectionSchema } from "./selection-types/normal";
+import { gameControlledSelectionSchema } from "./selection-types/game-controlled";
+import { unselectableSelectionSchema } from "./selection-types/unselectable";
+
+import {
+  untrustedScriptRefSchema, scriptRefSrcSchemaValidator, scriptRefMethodSchemaValidator,
+  untrustedScriptDictionarySchema
+} from "./script";
+export { untrustedScriptRefSchema };
+
+export const selectionConfigSchema: JSONSchemaType<RosterLockV1Config["selection"]> = {
+  type: "object",
+  required: ["piece", "scriptDictionary"],
+  additionalProperties: false,
+  properties: {
+    piece: {
+      type: "object",
+      required: [],
+      additionalProperties: {
+        oneOf: [
+          preselectedSelectionSchema,
+          normalSelectionSchema,
+          gameControlledSelectionSchema,
+          unselectableSelectionSchema
+        ],
+      },
+    },
+    globalValidation: {
+      type: "array",
+      items: untrustedScriptRefSchema,
+    },
+    scriptDictionary: untrustedScriptDictionarySchema
+  },
+};
+
+
+import { banListSchemaValidator } from "./selection-types/normal";
+import { preselectedSchemaValidator } from "./selection-types/preselected";
+
+export const selectionKeywords = [
+  banListSchemaValidator,
+
+  preselectedSchemaValidator,
+
+  scriptRefSrcSchemaValidator,
+  scriptRefMethodSchemaValidator,
+];

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

@@ -0,0 +1,54 @@
+
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Config, UntrustedScriptRef } from "@roster-lock/types";
+import { defineKeyword } from "../../../../../util-types/json-schema";
+
+import {
+  validateUntrustedScriptSrc,
+  validateUntrustedScriptMethod,
+} from "../validate/script";
+
+export const scriptRefSrcSchemaValidator = defineKeyword({
+  keyword: "untrustedScriptSrc",
+  type: "string",
+  validate(value, config: RosterLockV1Config){
+    validateUntrustedScriptSrc(value, config);
+  }
+});
+
+export const scriptRefMethodSchemaValidator = defineKeyword({
+  keyword: "untrustedScriptMethod",
+  type: "string",
+  validate(value, config: RosterLockV1Config){
+    validateUntrustedScriptMethod(value);
+  }
+});
+
+export const untrustedScriptRefSchema: JSONSchemaType<UntrustedScriptRef> = {
+  type: "object",
+  required: ["src"],
+  additionalProperties: false,
+  properties: {
+    src: {
+      type: "string",
+      [scriptRefSrcSchemaValidator.keyword]: true
+    },
+    method: {
+      type: "string", nullable: true,
+      [scriptRefMethodSchemaValidator.keyword]: true
+    }
+  },
+};
+
+
+export const untrustedScriptDictionarySchema: JSONSchemaType<RosterLockV1Config["selection"]["scriptDictionary"]> = {
+  type: "object", required: [],
+  propertyNames: { type: "string" },
+  additionalProperties: {
+    type: "object", required: ["content"],
+    additionalProperties: false,
+    properties: {
+      content: { type: "string" },
+    }
+  }
+};

package/src/match-lock-file/match-config/version-1/lock/selection/caster-json-schema/selection-types/game-controlled.ts

@@ -0,0 +1,11 @@
+import { JSONSchemaType } from "ajv";
+import { SelectionGameControlledConfig } from "@roster-lock/types";
+
+export const gameControlledSelectionSchema: JSONSchemaType<SelectionGameControlledConfig> = {
+  type: "object",
+  required: ["type"],
+  additionalProperties: false,
+  properties: {
+    type: { type: "string", const: "game-controlled" },
+  },
+};

package/src/match-lock-file/match-config/version-1/lock/selection/caster-json-schema/selection-types/normal.ts

@@ -0,0 +1,58 @@
+
+import { JSONSchemaType } from "ajv";
+import {
+  RosterLockV1Config,
+  SelectionNormalConfig,
+  UserSelectionValidation,
+} from "@roster-lock/types";
+
+import { untrustedScriptRefSchema } from "../script";
+import { validateSelectionBanList } from "../../validate/selections/normal";
+import { defineKeyword } from "../../../../../../util-types/json-schema";
+import { countSchema } from "../../../../shared/count";
+
+export const banListSchemaValidator = defineKeyword({
+  keyword: "selectionBanList",
+  type: "array",
+  validate: function (banList: Array<string>, { rosters }: RosterLockV1Config, path){
+    if(!banList) return;
+    // /selection/piece/pieceType/validation/banList
+    const pieceType = path.split("/").at(-3);
+    if(!pieceType) throw new Error("Invalid path");
+    const roster = rosters[pieceType];
+    validateSelectionBanList(banList, roster);
+  }
+});
+
+
+const userSelectionValidationSchema: JSONSchemaType<UserSelectionValidation> = {
+  type: "object",
+  required: ["count", "unique", "customValidation"],
+  additionalProperties: false,
+  properties: {
+    count: countSchema,
+    unique: { type: "boolean" },
+    banList: {
+      type: "array",
+      items: { type: "string" },
+      [banListSchemaValidator.keyword]: true,
+    },
+    customValidation: {
+      type: "array",
+      items: untrustedScriptRefSchema,
+    },
+  },
+};
+
+export const normalSelectionSchema: JSONSchemaType<SelectionNormalConfig> = {
+  type: "object",
+  required: ["type"],
+  additionalProperties: false,
+  properties: {
+    type: { type: "string", const: "normal" },
+    validation: userSelectionValidationSchema,
+    mergeAlgorithm: { ...untrustedScriptRefSchema, nullable: true },
+  },
+};
+
+

package/src/match-lock-file/match-config/version-1/lock/selection/caster-json-schema/selection-types/preselected.ts

@@ -0,0 +1,37 @@
+
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Config, SelectionPreselectedConfig } from "@roster-lock/types";
+import { validatePreselected } from "../../validate/selections/preselected";
+import { defineKeyword } from "../../../../../../util-types/json-schema";
+import { SelectedPieceSchema, SelectedPieceSchemaDef } from "../../../../shared";
+
+export const preselectedSchemaValidator = defineKeyword({
+  keyword: "selectionPreselected",
+  type: "array",
+  validate: function (
+    selection: SelectionPreselectedConfig["pieces"],
+    config: RosterLockV1Config,
+    path
+  ){
+    // /selection/piece/pieceType/pieces
+    const pieceType = path.split("/").at(-2);
+    if(!pieceType) throw new Error("Invalid path");
+    validatePreselected(selection, pieceType, config);
+  }
+});
+
+export const preselectedSelectionSchema = {
+  $id: "preselectedSelectionSchema",
+  type: "object",
+  required: ["type", "pieces"],
+  additionalProperties: false,
+  ...SelectedPieceSchemaDef,
+  properties: {
+    type: { type: "string", const: "preselected" },
+    pieces: {
+      type: "array",
+      [preselectedSchemaValidator.keyword]: true,
+      items: SelectedPieceSchema,
+    },
+  },
+} as unknown as JSONSchemaType<SelectionPreselectedConfig>;

package/src/match-lock-file/match-config/version-1/lock/selection/caster-json-schema/selection-types/unselectable.ts

@@ -0,0 +1,11 @@
+import { JSONSchemaType } from "ajv";
+import { SelectionUnselectableConfig } from "@roster-lock/types/src/v1/lock/selection/selection-types/unselectable";
+
+export const unselectableSelectionSchema: JSONSchemaType<SelectionUnselectableConfig> = {
+  type: "object",
+  required: ["type"],
+  additionalProperties: false,
+  properties: {
+    type: { type: "string", const: "unselectable" },
+  },
+};

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

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

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

@@ -0,0 +1,37 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+
+import { validateNormal } from "./selections/normal";
+import { validatePreselected } from "./selections/preselected";
+
+import { validateUntrustedScript } from "./script";
+
+export function validateSelectionConfig(
+  selectionConfig: RosterLockV1Config["selection"],
+  config: RosterLockV1Config
+){
+  const { engine, rosters } = config;
+  for(const [pieceType, selection] of Object.entries(selectionConfig.piece)){
+    const pieceDefinition = engine.pieceDefinitions[pieceType];
+    if(!pieceDefinition){
+      throw new Error(`Piece type ${pieceType} is not defined in engine`);
+    }
+    switch(selection.type){
+      case "preselected":
+        validatePreselected(selection.pieces, pieceType, config);
+        break;
+      case "normal":
+        validateNormal(selection, pieceType, config);
+        break;
+      case "game-controlled":
+        break;
+      case "unselectable":
+        break;
+    }
+  }
+  if(selectionConfig.globalValidation){
+    for(const script of selectionConfig.globalValidation){
+      validateUntrustedScript(script, config);
+    }
+  }
+}
+

package/src/match-lock-file/match-config/version-1/lock/selection/validate/script.ts

@@ -0,0 +1,28 @@
+import { UntrustedScriptRef, RosterLockV1Config } from "@roster-lock/types";
+
+export function validateUntrustedScript(
+  script: UntrustedScriptRef,
+  config: RosterLockV1Config
+){
+  validateUntrustedScriptSrc(script.src, config);
+  validateUntrustedScriptMethod(script.method);
+}
+
+export function validateUntrustedScriptSrc(
+  scriptSrc: UntrustedScriptRef["src"],
+  { selection }: RosterLockV1Config
+){
+  if(!(scriptSrc in selection.scriptDictionary)){
+    throw new Error("Script src is not in scripts");
+  }
+}
+
+const VALID_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+export function validateUntrustedScriptMethod(
+  method: UntrustedScriptRef["method"]
+){
+  if(method === undefined) return;
+  if(!VALID_IDENTIFIER.test(method)){
+    throw new Error("Script method must be a valid identifier");
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/selection/validate/selections/normal.ts

@@ -0,0 +1,69 @@
+
+import { RosterLockV1Config, SelectionNormalConfig, PieceType } from "@roster-lock/types";
+import { validateUntrustedScript } from "../script";
+import { validateCount } from "../../../../shared/count";
+
+export function validateNormal(
+  selection: SelectionNormalConfig,
+  pieceType: PieceType,
+  config: RosterLockV1Config
+){
+  validateRequiredProperties(selection, pieceType, config);
+
+  if("validation" in selection && selection.validation){
+    validateSelection(selection.validation, pieceType, config);
+  }
+  if(selection.mergeAlgorithm){
+    validateUntrustedScript(selection.mergeAlgorithm, config);
+  }
+}
+
+function validateRequiredProperties(
+  selection: SelectionNormalConfig,
+  pieceType: PieceType,
+  config: RosterLockV1Config
+){
+  const pieceDefinition = config.engine.pieceDefinitions[pieceType];
+  if(pieceDefinition.selectionStrategy === "on demand"){
+    if("validation" in selection && selection.validation){
+      throw new Error(`On demand piece ${pieceType} cannot have validation`);
+    }
+    if("mergeAlgorithm" in selection && selection.mergeAlgorithm){
+      throw new Error(`On demand piece ${pieceType} cannot have a merge algorithm`);
+    }
+    return;
+  }
+
+  if(pieceDefinition.selectionStrategy === "shared"){
+    if(!("mergeAlgorithm" in selection && selection.mergeAlgorithm)){
+      throw new Error(`Shared piece ${pieceType} must have a merge algorithm`);
+    }
+    return;
+  }
+}
+
+type SelectionValidation = NonNullable<SelectionNormalConfig["validation"]>;
+
+export function validateSelection(
+  validation: SelectionValidation,
+  pieceType: PieceType,
+  config: RosterLockV1Config
+){
+  validateCount(validation.count);
+  validateSelectionBanList(validation.banList || [], config.rosters[pieceType]);
+  for(const script of validation.customValidation){
+    validateUntrustedScript(script, config);
+  }
+}
+
+
+export function validateSelectionBanList(
+  banList: Array<string>,
+  roster: RosterLockV1Config["rosters"][string]
+){
+  for(const pieceId of banList){
+    if(!roster.find(p=>p.id === pieceId)){
+      throw new Error(`Ban list contains piece ${pieceId} which does not exist`);
+    }
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/selection/validate/selections/preselected.ts

@@ -0,0 +1,18 @@
+
+import { RosterLockV1Config, SelectionPreselectedConfig, PieceType } from "@roster-lock/types";
+
+import { ensurePiecesAreInRoster } from "../../../../usage/validate-select/ensure-pieces-are-in-roster";
+
+const PRESELECTABLE_STRATEGIES = ["shared", "personal"];
+export function validatePreselected(
+  selections: SelectionPreselectedConfig["pieces"],
+  pieceType: PieceType,
+  config: RosterLockV1Config
+){
+  const { engine } = config;
+  const defintion = engine.pieceDefinitions[pieceType];
+  if(!PRESELECTABLE_STRATEGIES.includes(defintion.selectionStrategy)){
+    throw new Error(`Piece type ${pieceType} is not preselectable`);
+  }
+  ensurePiecesAreInRoster(config, pieceType, selections);
+}

package/src/match-lock-file/match-config/version-1/piece-info/file-paths.ts

@@ -0,0 +1,2 @@
+
+export const PATH_ROSTERLOCK_PIECE_INFO = "rosterlock.piece-info.json"

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

@@ -0,0 +1,14 @@
+import { JSONSchemaCaster } from "../../../util-types/json-schema";
+
+import { RosterLockV1PieceInfo } from "@roster-lock/types";
+
+import { rosterLockPieceInfoKeywords } from "./keywords";
+
+import { rosterLockPieceInfoSchema } from "./schema";
+
+export const ROSTERLOCK_V1_PIECEINFO_CASTER_JSONSCHEMA = new JSONSchemaCaster<RosterLockV1PieceInfo>(
+  rosterLockPieceInfoSchema,
+  rosterLockPieceInfoKeywords
+);
+
+export * from "./file-paths"

package/src/match-lock-file/match-config/version-1/piece-info/keywords.ts

@@ -0,0 +1,39 @@
+
+import {
+  urlSchemaValidator,
+  friendlyStringSchemaValidator,
+} from "../lock/rosters/caster-json-schema/human";
+import {
+  downloadableSourceListSchemaValidator,
+} from "../lock/rosters/caster-json-schema/downloadableSources";
+import {
+  pathVariableNameSchemaValidator,
+  pathVariableValueSchemaValidator,
+  allPathVariableNameSetSchemaValidator,
+} from "../lock/rosters/caster-json-schema/pathVariables";
+
+import { defineKeyword } from "../../../util-types/json-schema";
+
+function ignore(){ return true; }
+
+export const rosterLockPieceInfoKeywords = [
+  urlSchemaValidator,
+  friendlyStringSchemaValidator,
+
+  downloadableSourceListSchemaValidator,
+  defineKeyword({
+    keyword: pathVariableNameSchemaValidator.keyword,
+    type: pathVariableNameSchemaValidator.type,
+    validate: ignore,
+  }),
+  defineKeyword({
+    keyword: pathVariableValueSchemaValidator.keyword,
+    type: pathVariableValueSchemaValidator.type,
+    validate: ignore,
+  }),
+  defineKeyword({
+    keyword: allPathVariableNameSetSchemaValidator.keyword,
+    type: allPathVariableNameSetSchemaValidator.type,
+    validate: ignore,
+  }),
+];

package/src/match-lock-file/match-config/version-1/piece-info/schema.ts

@@ -0,0 +1,29 @@
+
+import { humanInfoSchema } from "../lock/rosters/caster-json-schema/human";
+import {
+  downloadableSourcesSchema,
+} from "../lock/rosters/caster-json-schema/downloadableSources";
+import {
+  pathVariablesSchema,
+} from "../lock/rosters/caster-json-schema/pathVariables";
+
+import { JSONSchemaType } from "ajv";
+
+import { RosterLockV1PieceInfo } from "@roster-lock/types";
+
+import { buildIdentity } from "../shared";
+
+
+export const rosterLockPieceInfoSchema: JSONSchemaType<RosterLockV1PieceInfo> = {
+  type: "object",
+  required: ["configIdentity", "humanInfo", "downloadSources", "pathVariables"],
+  additionalProperties: false,
+  properties: {
+    configIdentity: buildIdentity("piece-info", 1),
+
+    humanInfo: humanInfoSchema,
+    downloadSources: downloadableSourcesSchema,
+    pathVariables: pathVariablesSchema,
+  },
+}
+

package/src/match-lock-file/match-config/version-1/shared/Identity.ts

@@ -0,0 +1,14 @@
+
+export function buildIdentity<P extends string, V extends number>(
+  purpose: P, version: V
+){
+  return {
+    type: "object" as const, required: ["namespace", "purpose", "version"] as const,
+    additionalProperties: false,
+    properties: {
+      namespace: { type: "string" as const, const: "roster-lock" as const },
+      purpose: { type: "string" as const, const: purpose },
+      version: { type: "number" as const, const: version },
+    }
+  };
+}

package/src/match-lock-file/match-config/version-1/shared/SelectedPiece.ts

@@ -0,0 +1,49 @@
+import { JSONSchemaType } from "ajv";
+import { SelectedPiece } from "@roster-lock/types";
+
+/*
+type SelectedPiece = {
+    id: string;
+    required: Record<string, {
+        mandatory: Array<SelectedPiece>;
+        selectable: Array<SelectedPiece>;
+    }>;
+}
+*/
+
+export const SelectedPieceSchemaDef = {
+  $defs: {
+    SelectedPiece: {
+      type: "object",
+      required: ["id", "required"],
+      additionalProperties: false,
+      properties: {
+        id: { type: "string" },
+        required: {
+          type: "object",
+          required: [],
+          additionalProperties: {
+            type: "object",
+            required: ["mandatory", "selectable"],
+            additionalProperties: false,
+            properties: {
+              mandatory: {
+                type: "array",
+                items: { $ref: "#/$defs/SelectedPiece" },
+              },
+              selectable: {
+                type: "array",
+                items: { $ref: "#/$defs/SelectedPiece" },
+              }
+            }
+          },
+        },
+      },
+    },
+  },
+};
+
+// AJV's JSONSchemaType doesn't support $ref-only schemas; cast is safe at runtime
+export const SelectedPieceSchema = {
+  $ref: "#/$defs/SelectedPiece"
+} as unknown as JSONSchemaType<SelectedPiece>;

package/src/match-lock-file/match-config/version-1/shared/count.ts

@@ -0,0 +1,47 @@
+
+import { JSONSchemaType } from "ajv";
+import { Count } from "@roster-lock/types";
+import { defineKeyword } from "../../../util-types/json-schema";
+
+export const countSchemaValidator = defineKeyword({
+  keyword: "Count",
+  type: ["number", "string", "array"],
+  validate: validateCount
+});
+
+
+export const countSchema: JSONSchemaType<Count> = {
+  [countSchemaValidator.keyword]: true,
+  type: ["number", "string", "array"],
+  anyOf: [
+    { type: "number", minimum: 1 },
+    { type: "string", const: "*" },
+    {
+      type: "array",
+      items: [
+        { type: "number", minimum: 0 },
+        { anyOf: [{ type: "number", minimum: 1 }, { type: "string", const: "*" }] },
+      ],
+      minItems: 2,
+      maxItems: 2,
+    },
+  ],
+};
+
+export function validateCount(count: Count){
+  if(!Array.isArray(count)){
+    if(count === "*") return;
+    if(count <= 0) throw new Error("count should be greater than 0");
+    return;
+  }
+  if(count.length !== 2){
+    throw new Error("range should be a single value or a range of two values");
+  }
+  if(count[0] < 0){
+    throw new Error("range should not have a negative minimum");
+  }
+  if(count[1] === "*") return;
+  if(count[0] >= count[1]){
+    throw new Error("maximum should be greater than the minimum");
+  }
+}

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

@@ -0,0 +1,9 @@
+
+export * from "./count";
+export * from "./Identity";
+export * from "./SelectedPiece";
+
+import { countSchemaValidator } from "./count";
+export const sharedKeywords = [
+  countSchemaValidator,
+];