@roster-lock/shared 0.1.0

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

@@ -0,0 +1,42 @@
+
+import {
+  CollectionId,
+  PieceType, PieceId,
+} from "../../../config-types";
+import {
+  DateTime,
+  Sha256,
+  URLType,
+  SemVer,
+  SignedContent,
+} from "../pieces/caster-runtypes/util-casters";
+
+import { MatchLockEngineConfig } from "../../engine";
+import { MatchLockSelectionConfig } from "../../selection";
+import { MatchLockPublishPiece } from "../../piece";
+
+export type MatchLockRestrictionPiece = (
+  MatchLockPublishPiece & {
+    id: PieceId,
+    requiredPieces?: Record<CollectionId, Array<PieceId>>
+  }
+);
+
+export type MatchLockRestrictionConfig = {
+  name: string,
+  version: SemVer,
+  published: DateTime,
+
+  sha256: Sha256,
+  signature: SignedContent,
+  signatureVerificationUrl: URLType,
+
+  engine: MatchLockEngineConfig,
+
+  pieces: Record<CollectionId, {
+    selectionConfig: MatchLockSelectionConfig,
+    pieceDefinition: PieceType,
+    pieces: Array<MatchLockRestrictionPiece>
+  }>
+}
+

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

@@ -0,0 +1,15 @@
+
+import { MatchLockRestrictionConfig } from "../types";
+import { validateRestrictionSha } from "./sha";
+import { validateEngineConfig } from "../../engine";
+import { validatePieces } from "./piece";
+
+export function validateMatchLockRestriction(restriction: MatchLockRestrictionConfig) {
+  validateRestrictionSha(restriction);
+  validateEngineConfig(restriction.engine);
+  validatePieces(restriction);
+  return true;
+}
+
+
+

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

@@ -0,0 +1,46 @@
+import { parseFilePath } from "../../../piece/version-0/caster-runtypes/util-casters";
+import { MatchLockRestrictionConfig, MatchLockRestrictionPiece } from "../../types";
+import {
+  validatePieceMatchesEngineDefinition,
+  validatePieceVersion,
+  validatePublishPieceSha,
+} from "../../../piece";
+
+export function validatePieces(restriction: MatchLockRestrictionConfig){
+  for(const [collectionId, collection] of Object.entries(restriction.pieces)){
+    if(!(collection.pieceDefinition in restriction.engine.pieceDefinitions)){
+      throw new Error(`Collection ${collectionId} is of  non existant type ${collection.pieceDefinition}`);
+    }
+    const ids = new Set<string>()
+    for(const piece of collection.pieces){
+      if(ids.has(piece.id)){
+        throw new Error(`Duplicate piece id ${piece.id} in collection ${collectionId}`);
+      }
+      ids.add(piece.id);
+
+      validatePiecesRequired(restriction, piece);
+      validatePieceMatchesEngineDefinition(restriction.engine, piece);
+      validatePieceVersion(restriction.engine, piece);
+      validatePublishPieceSha(piece);
+    }
+    validateMatchLockSelection(collection.selectionConfig, ids);
+  }
+}
+
+function validatePiecesRequired(
+  restriction: MatchLockRestrictionConfig, piece: MatchLockRestrictionPiece
+){
+  if(!piece.requiredPieces) return;
+  for(const [requiredCollectionId, requiredPieceIds] of Object.entries(piece.requiredPieces)){
+    if(!(requiredCollectionId in restriction.pieces)){
+      throw new Error(`Piece ${piece.id} requires piece from non existant collection ${requiredCollectionId}`);
+    }
+    for(const requiredPieceId of requiredPieceIds){
+      if(!restriction.pieces[requiredCollectionId].pieces.find(p=>p.id === requiredPieceId)){
+        throw new Error(`Piece ${piece.id} requires piece ${requiredPieceId} from collection ${requiredCollectionId} which does not exist`);
+      }
+    }
+  }
+}
+import { validateMatchLockSelection } from "../../../selection";
+

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

@@ -0,0 +1,19 @@
+
+import { MatchLockRestrictionConfig } from "../types";
+import { canonicalJSONStringify } from "../../../../utils/JSON";
+import { createSHA256Hash } from "../../piece/version-0/caster-runtypes/util-casters";
+
+export async function validateRestrictionSha(restriction: MatchLockRestrictionConfig){
+  const predictableString = canonicalJSONStringify({
+    name: restriction.name,
+    version: restriction.version,
+    published: restriction.published,
+
+    engine: restriction.engine,
+    pieces: restriction.pieces,
+  });
+  const sha = await createSHA256Hash(predictableString);
+  if(sha !== restriction.sha256){
+    throw new Error("Restriction's sha isn't equal to the expected")
+  };
+}

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

@@ -0,0 +1,105 @@
+
+
+import {
+  Record as CastRecord,
+  Object as CastObject,
+  Array as CastArray,
+  String as CastString,
+  Literal,
+  Union as CastUnion,
+  Tuple as CastTuple,
+  Boolean as CastBoolean,
+  Undefined as CastUndefined,
+} from "runtypes"
+
+
+import {
+  GasLimittedScript,
+  UserSelectionValidation,
+  ScriptWithPieceMeta,
+  MatchLockSelectionConfig
+} from "../../version-1/selection/types";
+import {
+  CountCaster,
+  JSONPrimitiveCaster,
+} from "../pieces/caster-runtypes/util-casters";
+import { JSON_Primitive } from "../../../../utils/JSON";
+
+
+const ScriptCaster = CastObject({
+  type: CastUnion(
+    Literal("text/typescript"),
+    Literal("text/javascript"),
+    Literal("text/lua"),
+  ),
+  content: CastString,
+}).conform<GasLimittedScript>();
+
+const SelectionCountCaster = CastUnion(
+  CountCaster,
+  CastTuple(CountCaster, CountCaster),
+).withConstraint((value) => {
+  if(!Array.isArray(value)){
+    if(value < 0) return "Count is negative";
+    return true;
+  }
+  if(value[0] < 0) return "Count range min is negative";
+  const [min, max] = value;
+  if(min > max) return "Count range min is greater than max";
+  return true;
+});
+
+export const ScriptWithPieceMetaCaster = CastObject({
+  name: CastString,
+  scriptMeta: CastObject({
+    defaultValue: CastRecord(CastString, JSONPrimitiveCaster),
+    pieceValues: CastRecord(CastString, CastRecord(CastString, CastUnion(JSONPrimitiveCaster, CastUndefined))),
+  }).optional(),
+  script: ScriptCaster,
+}).conform<ScriptWithPieceMeta<any>>();
+
+
+export const UserSelectionValidationCaster = CastObject({
+  count: SelectionCountCaster,
+  unique: CastBoolean,
+  customValidation: CastArray(ScriptWithPieceMetaCaster),
+}).conform<UserSelectionValidation>();
+
+
+export const MatchLockSelectionConfigCaster = CastUnion(
+  CastObject({
+    type: Literal("mandatory"),
+  }),
+  CastObject({
+    type: Literal("on-demand"),
+  }),
+  CastObject({
+    type: Literal("agreed"),
+  }),
+  CastObject({
+    type: Literal("player-choices"),
+    validation: CastObject({
+      count: SelectionCountCaster,
+      unique: CastBoolean,
+      customValidation: CastArray(ScriptWithPieceMetaCaster),
+    }),
+    algorithm: ScriptWithPieceMetaCaster.optional(),
+  }),
+  CastObject({
+    type: Literal("global-choices"),
+    validation: CastObject({
+      count: SelectionCountCaster,
+      unique: CastBoolean,
+      customValidation: CastArray(ScriptWithPieceMetaCaster),
+    }).optional(),
+    algorithm: ScriptWithPieceMetaCaster,
+  }),
+  CastObject({
+    type: Literal("democracy-random"),
+    validation: CastObject({
+      count: SelectionCountCaster,
+      unique: CastBoolean,
+      customValidation: CastArray(ScriptWithPieceMetaCaster),
+    }).optional(),
+  }),
+).conform<MatchLockSelectionConfig>();

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

@@ -0,0 +1,16 @@
+
+export function validateCount(count: number | [number, number]){
+  if(!Array.isArray(count)){
+    if(count < 0){
+      throw new Error(`Count ${count} is negative`);
+    }
+    return;
+  }
+  const [min, max] = count;
+  if(min < 0){
+    throw new Error(`Count ${min} is negative`);
+  }
+  if(max < min){
+    throw new Error(`Count ${max} is less than ${min}`);
+  }
+}

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

@@ -0,0 +1,40 @@
+import { MatchLockSelectionConfig } from "../../types";
+import { validateCount } from "./count";
+import { validateScriptMeta } from "./scriptMeta";
+
+export function validateMatchLockSelection(
+  selection: MatchLockSelectionConfig, pieceIds: Set<string>
+) {
+  switch(selection.type){
+    case "mandatory":
+      return;
+    case "on-demand":
+      return;
+    case "agreed":
+      return;
+    case "player-choices":
+      validateCount(selection.validation.count);
+      for(const script of selection.validation.customValidation){
+        validateScriptMeta(script, pieceIds);
+      }
+      if(!selection.algorithm) return;
+      validateScriptMeta(selection.algorithm, pieceIds);
+      return;
+    case "global-choices":
+      if(selection.validation){
+        validateCount(selection.validation.count);
+        for(const script of selection.validation.customValidation){
+          validateScriptMeta(script, pieceIds);
+        }
+      }
+      validateScriptMeta(selection.algorithm, pieceIds);
+      return;
+    case "democracy-random":
+      if(!selection.validation) return;
+      validateCount(selection.validation.count);
+      if(!selection.validation.customValidation) return;
+      for(const script of selection.validation.customValidation){
+        validateScriptMeta(script, pieceIds);
+      }
+  }
+}

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

@@ -0,0 +1,26 @@
+
+import { ScriptWithPieceMeta } from "../../types";
+
+export function validateScriptMeta(
+  script: ScriptWithPieceMeta<any>, pieceIds: Set<string>
+){
+  if(!script.scriptMeta) return;
+  const defaultType = script.scriptMeta.defaultValue;
+  const types: Record<string, string> = {};
+  for(const key in defaultType){
+    types[key] = typeof defaultType[key];
+  }
+  for(const [pieceId, pieceMeta] of Object.entries(script.scriptMeta.pieceValues)){
+    if(!pieceIds.has(pieceId)){
+      throw new Error(`Script ${script.name} references piece ${pieceId} which is not in the piece ids`);
+    }
+    for(const key in pieceMeta){
+      if(!(key in types)){
+        throw new Error(`Script ${script.name} references piece ${pieceId} with meta key ${key} which is not in the default meta`);
+      }
+      if(typeof pieceMeta[key] !== types[key]){
+        throw new Error(`Script ${script.name} references piece ${pieceId} with meta key ${key} which is not the same type as the default meta`);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,52 @@
+
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Draft } from "@roster-lock/types";
+import { JSONSchemaCaster, defineKeyword } from "../../../util-types/json-schema";
+
+import { RosterLockV1Schema, RosterLockV1SchemaKeywords } from "../lock";
+
+import { buildIdentity } from "../shared";
+
+import { rosterPieceInfoSchema } from "./roster-piece-info";
+import { selectionScriptInfoSchema } from "./selection-script-info";
+
+export const RosterLockV1DraftSchema: JSONSchemaType<RosterLockV1Draft> = {
+  type: "object",
+  required: ["configIdentity", "previousLock", "stagedLock", "draft"],
+  additionalProperties: false,
+  $defs: {
+    RosterLockV1Config: RosterLockV1Schema,
+  },
+  properties: {
+    configIdentity: buildIdentity("draft", 1),
+    previousLock: { $ref: "#/$defs/RosterLockV1Config" },
+    stagedLock: { $ref: "#/$defs/RosterLockV1Config" },
+    draft: {
+      type: "object", required: ["rosterPieceInfo", "selectionScriptInfo"],
+      additionalProperties: false,
+      properties: {
+        rosterPieceInfo: {
+          type: "object", required: [],
+          additionalProperties: {
+            type: "object", required: [],
+            additionalProperties: rosterPieceInfoSchema
+          }
+        },
+        selectionScriptInfo: {
+          type: "object", required: [],
+          additionalProperties: selectionScriptInfoSchema
+        }
+      }
+    }
+  },
+} as JSONSchemaType<RosterLockV1Draft>;
+
+function ignore(){ return true; }
+export const RosterLockV1DraftSchemaKeywords = RosterLockV1SchemaKeywords.map((keywordDef)=>{
+  return defineKeyword({ keyword: keywordDef.keyword, type: keywordDef.type, validate: ignore });
+});
+
+export const ROSTERLOCK_V1_DRAFT_CASTER_JSONSCHEMA = new JSONSchemaCaster<RosterLockV1Draft>(
+  RosterLockV1DraftSchema,
+  RosterLockV1DraftSchemaKeywords,
+);

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

@@ -0,0 +1,33 @@
+
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Draft } from "@roster-lock/types";
+
+type RosterLockDraftPieceInfo = RosterLockV1Draft["draft"]["rosterPieceInfo"]["string"]["string"];
+export const rosterPieceInfoSchema: JSONSchemaType<RosterLockDraftPieceInfo> = {
+  type: "object", additionalProperties: false,
+  required: ["testedDownloadSources"],
+  properties: {
+    referenceFolder: { type: "string", nullable: true },
+    testedDownloadSources: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["source", "testedAt", "version"],
+        additionalProperties: false,
+        properties: {
+          source: { type: "string" },
+          testedAt: { type: "number" },
+          version: {
+            type: "object", additionalProperties: false,
+            required: ["logic", "media", "docs"],
+            properties: {
+              logic: { type: "string" },
+              media: { type: "string" },
+              docs: { type: "string" },
+            }
+          }
+        },
+      },
+    },
+  },
+};

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

@@ -0,0 +1,16 @@
+
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Draft } from "@roster-lock/types";
+
+type RosterLockDraftScriptInfo = RosterLockV1Draft["draft"]["selectionScriptInfo"][string];
+
+
+export const selectionScriptInfoSchema: JSONSchemaType<RosterLockDraftScriptInfo> = {
+  type: "object", required: ["lastLoad", "sha", "referencePath"],
+  additionalProperties: false,
+  properties: {
+    lastLoad: { type: "number" },
+    sha: { type: "string" },
+    referencePath: { type: "string" },
+  }
+};

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

@@ -0,0 +1,7 @@
+
+export * from "./lock";
+export * from "./draft";
+export * from "./piece-info";
+export * from "./shared";
+
+export * from "./usage";

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

@@ -0,0 +1,46 @@
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Config } from "@roster-lock/types";
+import { countSchema } from "../../../../shared/count";
+type RosterLockEngineConfig = RosterLockV1Config["engine"];
+
+
+import {
+  assetNameSchemaValidator,
+  assetGlobListSchemaValidator,
+  assetGlobPathVariablesSchemaValidator,
+  assetGlobItemSchemaValidator,
+} from "./keywords";
+export const assetsSchema: JSONSchemaType<
+  RosterLockEngineConfig["pieceDefinitions"][string]["assets"]
+> = {
+  type: "array",
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["name", "classification", "count", "glob"],
+    properties: {
+      name: {
+        [assetNameSchemaValidator.keyword]: true,
+        type: "string"
+      },
+      classification: { type: "string", enum: ["logic", "media", "doc"] },
+      count: countSchema,
+      glob: {
+        [assetGlobListSchemaValidator.keyword]: true,
+        type: "array",
+        items: {
+          [assetGlobPathVariablesSchemaValidator.keyword]: true,
+          [assetGlobItemSchemaValidator.keyword]: true,
+          type: "string",
+        },
+      },
+    }
+  }
+};
+
+export const assetKeywords = [
+  assetNameSchemaValidator,
+  assetGlobListSchemaValidator,
+  assetGlobPathVariablesSchemaValidator,
+  assetGlobItemSchemaValidator,
+];

package/src/match-lock-file/match-config/version-1/lock/engine/caster-json-schema/asset/keywords.ts

@@ -0,0 +1,48 @@
+import { defineKeyword } from "../../../../../../util-types/json-schema";
+import { RosterLockV1Config } from "@roster-lock/types";
+
+
+import { validateAssetName } from "../../validate/piece/assets";
+export const assetNameSchemaValidator = defineKeyword({
+  keyword: "assetName",
+  type: "string",
+  validate: function(name: string, { engine }: RosterLockV1Config, path){
+    // /engine/pieceDefinitions/pieceType/assets/index/name
+    const pathParts = path.split("/").slice(0, -3);
+    const pieceType = pathParts.at(-1);
+    if(!pieceType) throw new Error("Invalid path");
+    const assets = engine.pieceDefinitions[pieceType].assets;
+    validateAssetName(name, assets);
+  }
+});
+
+import { validateGlobList } from "../../validate/piece/assets";
+export const assetGlobListSchemaValidator = defineKeyword({
+  keyword: "assetGlobList",
+  type: "array",
+  validate: validateGlobList
+});
+
+import { validatePathVariablesInGlob } from "../../validate/piece/assets/glob/pathvariables";
+export const assetGlobPathVariablesSchemaValidator = defineKeyword({
+  keyword: "assetGlobPathVariables",
+  type: "string",
+  validate: function(globItem: string, { engine }: RosterLockV1Config, path){
+    // /engine/pieceDefinitions/pieceType/assets/index/glob/index
+    const pathParts = path.split("/").slice(0, -4);
+    const pieceType = pathParts.at(-1);
+    if(!pieceType) throw new Error("Invalid path");
+    const variables = engine.pieceDefinitions[pieceType].pathVariables;
+    validatePathVariablesInGlob(globItem, variables);
+  },
+});
+
+import { validateGlobItem } from "../../validate/piece/assets/glob";
+export const assetGlobItemSchemaValidator = defineKeyword({
+  keyword: "assetGlobItem",
+  type: "string",
+  validate: validateGlobItem
+});
+
+
+

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

@@ -0,0 +1,6 @@
+
+
+import { engineSchema, engineKeywords } from "./schema";
+
+export { engineSchema, engineKeywords };
+

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

@@ -0,0 +1,42 @@
+import { JSONSchemaType } from "ajv";
+import { defineKeyword } from "../../../../../util-types/json-schema";
+import { RosterLockV1Config } from "@roster-lock/types";
+import { sha256SchemaValidator } from "../../rosters/caster-json-schema/version";
+
+export const officialSelectionHashUniquenessSchemaValidator = defineKeyword({
+  keyword: "officialSelectionHashUniqueness",
+  type: "string",
+  validate: function (hash: string, { engine }: RosterLockV1Config, path){
+    // /engine/officialSelections/index/hash
+    const index = Number(path.split("/").at(-2));
+    if(Number.isNaN(index)) throw new Error("Invalid path: index is not a number");
+    const list = engine.officialSelections ?? [];
+    for(let i = 0; i < list.length; i++){
+      if(i === index) continue;
+      if(list[i].hash === hash) throw new Error(`Duplicate official selection hash ${hash}`);
+    }
+  }
+});
+
+export const officialSelectionsSchema: JSONSchemaType<
+  NonNullable<RosterLockV1Config["engine"]["officialSelections"]>
+> = {
+  type: "array",
+  items: {
+    type: "object",
+    required: ["tag", "hash"],
+    additionalProperties: false,
+    properties: {
+      tag: { type: "string" },
+      hash: {
+        type: "string",
+        [sha256SchemaValidator.keyword]: true,
+        [officialSelectionHashUniquenessSchemaValidator.keyword]: true,
+      },
+    },
+  },
+};
+
+export const officialSelectionsKeywords = [
+  officialSelectionHashUniquenessSchemaValidator,
+];

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

@@ -0,0 +1,26 @@
+
+import { JSONSchemaType } from "ajv";
+import { requirementListSchemaValidator, requirementItemSchemaValidator, requirementCycleSchemaValidator } from "./keywords";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockEngineConfig = RosterLockV1Config["engine"];
+
+export { requirementCycleSchemaValidator };
+
+export const requirementKeywords = [
+  requirementListSchemaValidator,
+  requirementItemSchemaValidator,
+  requirementCycleSchemaValidator,
+]
+
+
+export const requirementsSchema: JSONSchemaType<
+  RosterLockEngineConfig["pieceDefinitions"][string]["requires"]
+> = {
+  [requirementListSchemaValidator.keyword]: true,
+  [requirementCycleSchemaValidator.keyword]: true,
+  type: "array",
+  items: {
+    [requirementItemSchemaValidator.keyword]: true,
+    type: "string",
+  },
+}

package/src/match-lock-file/match-config/version-1/lock/engine/caster-json-schema/requirements/keywords.ts

@@ -0,0 +1,34 @@
+import { defineKeyword } from "../../../../../../util-types/json-schema";
+import { RosterLockV1Config } from "@roster-lock/types";
+
+import { validatePieceRequirementList } from "../../validate/piece/requirements";
+export const requirementListSchemaValidator = defineKeyword({
+  keyword: "requirementList",
+  type: "array",
+  validate: validatePieceRequirementList
+})
+
+import { validatePieceInCycles } from "../../validate/piece/requirements";
+export const requirementCycleSchemaValidator = defineKeyword({
+  keyword: "requirementCycle",
+  type: "array",
+  validate: function(item: string, { engine }: RosterLockV1Config, path){
+    // /engine/pieceDefinitions/pieceType/requires
+    const parts = path.split("/").slice(0, -1);
+    const pieceType = parts.at(-1);
+    if(!pieceType) throw new Error("Invalid path");
+
+    validatePieceInCycles(pieceType, engine);
+  }
+})
+
+import { validatePieceRequirementIsResolved } from "../../validate/piece/requirements";
+export const requirementItemSchemaValidator = defineKeyword({
+  keyword: "requirementResolved",
+  type: "string",
+  validate: function(item: string, { engine }: RosterLockV1Config, path){
+    // /engine/pieceDefinitions/pieceType/requires/index
+    validatePieceRequirementIsResolved(item, engine);
+  }
+})
+