@xnetjs/data 0.0.2 → 0.1.0

package/dist/chunk-BY5O6LNC.js

@@ -0,0 +1,380 @@
+import {
+  checkbox,
+  defineSchema,
+  number,
+  person,
+  select,
+  text
+} from "./chunk-EBNMV2VO.js";
+
+// src/schema/schemas/system.ts
+import { base64ToBytes, hashHex, verify } from "@xnetjs/crypto";
+import { parseDID } from "@xnetjs/identity";
+var SCHEMA_STATUS_OPTIONS = [
+  { id: "draft", name: "Draft", color: "gray" },
+  { id: "published", name: "Published", color: "green" },
+  { id: "deprecated", name: "Deprecated", color: "yellow" },
+  { id: "revoked", name: "Revoked", color: "red" }
+];
+var COMPATIBILITY_MODE_OPTIONS = [
+  { id: "compatible", name: "Compatible", color: "green" },
+  { id: "requires-lens", name: "Requires Lens", color: "yellow" },
+  { id: "breaking", name: "Breaking", color: "red" }
+];
+var POLICY_STATUS_OPTIONS = [
+  { id: "active", name: "Active", color: "green" },
+  { id: "superseded", name: "Superseded", color: "yellow" },
+  { id: "revoked", name: "Revoked", color: "red" }
+];
+var PRESENCE_VISIBILITY_OPTIONS = [
+  { id: "private", name: "Private", color: "gray" },
+  { id: "trusted-app", name: "Trusted App", color: "blue" },
+  { id: "public-metadata", name: "Public Metadata", color: "green" }
+];
+var PRESENCE_COUNT_BUCKET_OPTIONS = [
+  { id: "0", name: "0", color: "gray" },
+  { id: "1", name: "1", color: "gray" },
+  { id: "2-5", name: "2-5", color: "blue" },
+  { id: "6-20", name: "6-20", color: "blue" },
+  { id: "21-100", name: "21-100", color: "green" },
+  { id: "100+", name: "100+", color: "green" }
+];
+var SCHEMA_IRI_PATTERN = /^xnet:\/\/[^/]+\/.+/;
+var SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+var CONTENT_HASH_PATTERN = /^cid:blake3:[0-9a-f]{64}$/;
+var SYSTEM_NAMESPACE_KINDS = ["schema", "compat", "policy", "presence", "authz"];
+var SchemaDefinitionSchema = defineSchema({
+  name: "SchemaDefinition",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    schemaIri: text({ required: true, pattern: SCHEMA_IRI_PATTERN }),
+    version: text({ required: true, pattern: SEMVER_PATTERN }),
+    authority: text({ required: true }),
+    definitionBytes: text({ required: true, minLength: 2 }),
+    contentHash: text({ required: true, pattern: CONTENT_HASH_PATTERN }),
+    publishedAt: number({ required: true, integer: true, min: 0 }),
+    status: select({ options: SCHEMA_STATUS_OPTIONS, required: true, default: "draft" }),
+    signature: text({ required: true, minLength: 80 }),
+    signingKeyId: text({ required: true }),
+    policyDefaults: text({}),
+    authorityProof: text({})
+  }
+});
+var SchemaCompatibilitySchema = defineSchema({
+  name: "SchemaCompatibility",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    fromSchema: text({ required: true, pattern: SCHEMA_IRI_PATTERN }),
+    toSchema: text({ required: true, pattern: SCHEMA_IRI_PATTERN }),
+    mode: select({ options: COMPATIBILITY_MODE_OPTIONS, required: true }),
+    lossless: checkbox({ default: false }),
+    lensRef: text({}),
+    validatedAt: number({ required: true, integer: true, min: 0 }),
+    validatedBy: person({})
+  }
+});
+var SyncPolicySchema = defineSchema({
+  name: "SyncPolicy",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    subjectDid: person({ required: true }),
+    matchRules: text({ required: true, minLength: 2 }),
+    destinations: text({ required: true, minLength: 2 }),
+    priority: number({ required: true, integer: true, min: 0 }),
+    revision: number({ required: true, integer: true, min: 1 }),
+    effectiveFrom: number({ required: true, integer: true, min: 0 }),
+    expiresAt: number({ integer: true, min: 0 }),
+    status: select({ options: POLICY_STATUS_OPTIONS, required: true, default: "active" })
+  }
+});
+var PresenceSummarySchema = defineSchema({
+  name: "PresenceSummary",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    subjectDid: person({ required: true }),
+    schemaIri: text({ required: true, pattern: SCHEMA_IRI_PATTERN }),
+    namespace: text({ required: true }),
+    countBucket: select({ options: PRESENCE_COUNT_BUCKET_OPTIONS, required: true }),
+    visibility: select({ options: PRESENCE_VISIBILITY_OPTIONS, required: true }),
+    lastUpdatedAt: number({ required: true, integer: true, min: 0 }),
+    sourcePolicy: text({}),
+    noise: text({})
+  }
+});
+var SYSTEM_SCHEMA_IRIS = {
+  SchemaDefinition: SchemaDefinitionSchema.schema["@id"],
+  SchemaCompatibility: SchemaCompatibilitySchema.schema["@id"],
+  SyncPolicy: SyncPolicySchema.schema["@id"],
+  PresenceSummary: PresenceSummarySchema.schema["@id"]
+};
+var SYSTEM_SCHEMA_BASE_IRIS = {
+  SchemaDefinition: "xnet://xnet.fyi/SchemaDefinition",
+  SchemaCompatibility: "xnet://xnet.fyi/SchemaCompatibility",
+  SyncPolicy: "xnet://xnet.fyi/SyncPolicy",
+  PresenceSummary: "xnet://xnet.fyi/PresenceSummary",
+  Grant: "xnet://xnet.fyi/Grant"
+};
+function isSystemSchemaIri(schemaIri) {
+  return Object.values(SYSTEM_SCHEMA_IRIS).some((iri) => schemaIri === iri) || Object.values(SYSTEM_SCHEMA_BASE_IRIS).some((iri) => schemaIri === iri);
+}
+function buildSystemNamespace(subjectDid, kind) {
+  return `xnet://${subjectDid}/sys/${kind}/`;
+}
+function buildSystemNodeId(subjectDid, kind, localId) {
+  return `${buildSystemNamespace(subjectDid, kind)}${localId.replace(/^\/+/, "")}`;
+}
+function parseSystemNamespaceResource(resource) {
+  const kinds = SYSTEM_NAMESPACE_KINDS.join("|");
+  const match = new RegExp(`^xnet://(did:key:[^/]+)/sys/(${kinds})(?:/(.*))?$`).exec(resource);
+  if (!match) {
+    return null;
+  }
+  const [, subjectDid, kind, localId = ""] = match;
+  return {
+    subjectDid,
+    kind,
+    namespace: buildSystemNamespace(subjectDid, kind),
+    localId
+  };
+}
+function isSystemNamespaceResource(resource) {
+  return parseSystemNamespaceResource(resource) !== null;
+}
+function resolveSchemaAuthority(options) {
+  const authority = extractSchemaIriAuthority(options.schemaIri);
+  const declaredAuthority = options.authority ?? authority ?? "";
+  const errors = [];
+  if (!authority) {
+    errors.push({
+      path: "schemaIri",
+      message: "schemaIri must use xnet://<authority>/<name> format",
+      value: options.schemaIri
+    });
+    return { valid: false, errors, kind: "invalid", authority: declaredAuthority };
+  }
+  if (declaredAuthority !== authority) {
+    errors.push({
+      path: "authority",
+      message: "authority must match schema IRI authority",
+      value: declaredAuthority
+    });
+  }
+  if (authority.startsWith("did:key:")) {
+    if (options.publisherDid && options.publisherDid !== authority) {
+      errors.push({
+        path: "publisherDid",
+        message: "DID authority schemas must be published by the authority DID",
+        value: options.publisherDid
+      });
+    }
+    return { valid: errors.length === 0, errors, kind: "did", authority };
+  }
+  if (!options.allowDomainAuthority) {
+    errors.push({
+      path: "schemaIri",
+      message: "domain authority schemas require explicit domain linkage policy",
+      value: options.schemaIri
+    });
+  }
+  if (options.allowDomainAuthority && !options.domainLinkageProof) {
+    errors.push({
+      path: "domainLinkageProof",
+      message: "domain authority schemas require a domain linkage proof"
+    });
+  }
+  return { valid: errors.length === 0, errors, kind: "domain", authority };
+}
+function computeSchemaDefinitionContentHash(definitionBytes) {
+  return `cid:blake3:${hashHex(new TextEncoder().encode(definitionBytes))}`;
+}
+function createSchemaDefinitionSigningPayload(input) {
+  return new TextEncoder().encode(canonicalJson(input));
+}
+function validateSchemaDefinitionNode(node, options = {}) {
+  const flattened = flattenNodeProperties(node);
+  const schemaResult = SchemaDefinitionSchema.validate(flattened);
+  const errors = [...schemaResult.errors];
+  const schemaIri = asString(flattened.schemaIri);
+  const version = asString(flattened.version);
+  const authority = asString(flattened.authority);
+  const definitionBytes = asString(flattened.definitionBytes);
+  const contentHash = asString(flattened.contentHash);
+  const signature = asString(flattened.signature);
+  const publishedAt = asNumber(flattened.publishedAt);
+  const status = asSchemaDefinitionStatus(flattened.status);
+  const authorityProof = asString(flattened.authorityProof);
+  if (schemaIri && authority) {
+    const authorityResult = resolveSchemaAuthority({
+      schemaIri,
+      authority,
+      publisherDid: options.publisherDid ?? asDid(flattened.createdBy),
+      allowDomainAuthority: options.allowDomainAuthority,
+      domainLinkageProof: options.domainLinkageProof ?? authorityProof ?? void 0
+    });
+    errors.push(...authorityResult.errors);
+  }
+  if (definitionBytes && contentHash) {
+    const expectedHash = computeSchemaDefinitionContentHash(definitionBytes);
+    if (contentHash !== expectedHash) {
+      errors.push({
+        path: "contentHash",
+        message: "contentHash must match definitionBytes",
+        value: contentHash
+      });
+    }
+    const parsedDefinition = parseSchemaJson(definitionBytes);
+    if (!parsedDefinition) {
+      errors.push({
+        path: "definitionBytes",
+        message: "definitionBytes must contain a valid JSON schema definition"
+      });
+    } else {
+      if (parsedDefinition["@id"] !== schemaIri) {
+        errors.push({
+          path: "definitionBytes.@id",
+          message: "embedded schema @id must match schemaIri",
+          value: parsedDefinition["@id"]
+        });
+      }
+      if (parsedDefinition.version !== version) {
+        errors.push({
+          path: "definitionBytes.version",
+          message: "embedded schema version must match version",
+          value: parsedDefinition.version
+        });
+      }
+    }
+  }
+  if (schemaIri && version && authority && contentHash && publishedAt !== null && status && signature) {
+    const signatureResult = validateSchemaDefinitionSignature({
+      signature,
+      authority,
+      authorityPublicKey: options.authorityPublicKey,
+      payload: createSchemaDefinitionSigningPayload({
+        schemaIri,
+        version,
+        authority,
+        contentHash,
+        publishedAt,
+        status
+      })
+    });
+    errors.push(...signatureResult.errors);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateSchemaDefinitionSignature(input) {
+  const errors = [];
+  let signatureBytes;
+  try {
+    signatureBytes = base64ToBytes(input.signature);
+  } catch {
+    return {
+      valid: false,
+      errors: [{ path: "signature", message: "signature must be base64 encoded" }]
+    };
+  }
+  if (signatureBytes.length !== 64) {
+    errors.push({
+      path: "signature",
+      message: "signature must be an Ed25519 signature"
+    });
+  }
+  const publicKey = input.authorityPublicKey ?? getAuthorityPublicKey(input.authority);
+  if (publicKey && !verify(input.payload, signatureBytes, publicKey)) {
+    errors.push({
+      path: "signature",
+      message: "signature must verify against schema authority"
+    });
+  }
+  return { valid: errors.length === 0, errors };
+}
+function getAuthorityPublicKey(authority) {
+  if (!authority.startsWith("did:key:")) {
+    return null;
+  }
+  try {
+    return parseDID(authority);
+  } catch {
+    return null;
+  }
+}
+function extractSchemaIriAuthority(schemaIri) {
+  const match = /^xnet:\/\/([^/]+)\/.+/.exec(schemaIri);
+  return match?.[1] ?? null;
+}
+function flattenNodeProperties(node) {
+  if (!isRecord(node)) {
+    return {};
+  }
+  if (isRecord(node.properties)) {
+    return {
+      id: node.id,
+      schemaId: node.schemaId,
+      createdAt: node.createdAt,
+      createdBy: node.createdBy,
+      ...node.properties
+    };
+  }
+  return node;
+}
+function parseSchemaJson(definitionBytes) {
+  try {
+    const parsed = JSON.parse(definitionBytes);
+    if (!isRecord(parsed)) return null;
+    if (typeof parsed["@id"] !== "string") return null;
+    if (typeof parsed.version !== "string") return null;
+    if (!Array.isArray(parsed.properties)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(sortKeys);
+  }
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, sortKeys(entry)])
+  );
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object");
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asDid(value) {
+  return typeof value === "string" && value.startsWith("did:key:") ? value : void 0;
+}
+function asSchemaDefinitionStatus(value) {
+  return SCHEMA_STATUS_OPTIONS.some((option) => option.id === value) ? value : null;
+}
+
+export {
+  SYSTEM_NAMESPACE_KINDS,
+  SchemaDefinitionSchema,
+  SchemaCompatibilitySchema,
+  SyncPolicySchema,
+  PresenceSummarySchema,
+  SYSTEM_SCHEMA_IRIS,
+  SYSTEM_SCHEMA_BASE_IRIS,
+  isSystemSchemaIri,
+  buildSystemNamespace,
+  buildSystemNodeId,
+  parseSystemNamespaceResource,
+  isSystemNamespaceResource,
+  resolveSchemaAuthority,
+  computeSchemaDefinitionContentHash,
+  createSchemaDefinitionSigningPayload,
+  validateSchemaDefinitionNode
+};

package/dist/chunk-DCTRX6II.js

@@ -0,0 +1,40 @@
+import {
+  created,
+  createdBy,
+  defineSchema,
+  person,
+  text
+} from "./chunk-EBNMV2VO.js";
+
+// src/schema/schemas/profile.ts
+var ProfileSchema = defineSchema({
+  name: "Profile",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** The DID this profile describes (should match createdBy) */
+    did: person({ required: true }),
+    /** Human-readable display name */
+    displayName: text({ required: true, maxLength: 120 }),
+    /**
+     * Optional @handle — a short, workspace-unique slug for typing mentions
+     * (exploration 0172). The stable identity is always the DID; the handle is
+     * a resolver input at compose time and a display option at read time, so a
+     * rename never breaks an existing mention. Global uniqueness is out of
+     * scope — the DID remains the source of truth.
+     */
+    handle: text({ maxLength: 32 }),
+    /** Avatar URL or blob reference */
+    avatar: text({ maxLength: 500 }),
+    /** Short status emoji (e.g. 🔴, 🌴) */
+    statusEmoji: text({ maxLength: 32 }),
+    /** Free-form status message */
+    statusMessage: text({ maxLength: 200 }),
+    createdAt: created(),
+    createdBy: createdBy()
+  },
+  document: void 0
+});
+
+export {
+  ProfileSchema
+};

package/dist/{chunk-VYR5GPJP.js → chunk-DWEXKD6E.js}

@@ -1,20 +1,24 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-OCMSAKWV.js";
 import {
   defineSchema,
   relation,
   text
-} from "./chunk-SZC345Z2.js";
+} from "./chunk-EBNMV2VO.js";
 
 // src/schema/schemas/database-row.ts
 var DatabaseRowSchema = defineSchema({
   name: "DatabaseRow",
   namespace: "xnet://xnet.fyi/",
+  version: "2.0.0",
   properties: {
     /**
      * Reference to the parent database.
      * This is a typed relation that only accepts Database node IDs.
      */
     database: relation({
-      target: "xnet://xnet.fyi/Database@1.0.0",
+      target: "xnet://xnet.fyi/Database@2.0.0",
       required: true
     }),
     /**
@@ -31,7 +35,9 @@ var DatabaseRowSchema = defineSchema({
    * Only created when the row has rich text columns.
    * Each rich text column gets its own Y.XmlFragment in the doc.
    */
-  document: "yjs"
+  document: "yjs",
+  // Inherits access from its home Space (exploration 0181/0192).
+  authorization: spaceCascadeAuthorization("database")
 });
 
 export {