@iann29/rastro 0.1.0-alpha.0

package/src/component/_generated/dataModel.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+  SystemTableNames,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> =
+  GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/src/component/_generated/server.ts

@@ -0,0 +1,169 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+/**
+ * Typesafe environment variables.
+ *
+ * This includes platform-provided env vars and any variables declared in
+ * `convex.config.ts`.
+ */
+type Env = {
+  readonly CONVEX_CLOUD_URL: string;
+  readonly CONVEX_SITE_URL: string;
+};
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query: QueryBuilder<DataModel, "public"> = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery: QueryBuilder<DataModel, "internal"> =
+  internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation: MutationBuilder<DataModel, "public"> = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation: MutationBuilder<DataModel, "internal"> =
+  internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action: ActionBuilder<DataModel, "public"> = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction: ActionBuilder<DataModel, "internal"> =
+  internalActionGeneric;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction: HttpActionBuilder = httpActionGeneric;
+export const env: Env = (globalThis as unknown as { process: { env: Env } })
+  .process.env;
+
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/src/component/affiliates.ts

@@ -0,0 +1,119 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+import { MAX_AFFILIATES_PER_SITE } from "./constants.js";
+import { fail } from "./errors.js";
+import { cleanString, sanitizeSlug } from "./sanitize.js";
+import { affiliateFieldsValidator } from "./validators.js";
+
+const affiliateDocumentValidator = affiliateFieldsValidator.extend({
+  _id: v.id("affiliates"),
+  _creationTime: v.number(),
+});
+
+export const upsert = mutation({
+  args: {
+    siteId: v.id("sites"),
+    affiliateId: v.optional(v.id("affiliates")),
+    slug: v.string(),
+    name: v.string(),
+    commissionBps: v.number(),
+    attributionWindowDays: v.number(),
+    active: v.optional(v.boolean()),
+  },
+  returns: v.id("affiliates"),
+  handler: async (ctx, args) => {
+    if (!(await ctx.db.get("sites", args.siteId))) fail("NOT_FOUND", "site not found");
+    if (!Number.isSafeInteger(args.commissionBps) || args.commissionBps < 0 || args.commissionBps > 10_000) {
+      fail("INVALID_ARGUMENT", "commissionBps must be an integer between 0 and 10000");
+    }
+    if (
+      !Number.isSafeInteger(args.attributionWindowDays) ||
+      args.attributionWindowDays < 1 ||
+      args.attributionWindowDays > 365
+    ) {
+      fail("INVALID_ARGUMENT", "attributionWindowDays must be an integer between 1 and 365");
+    }
+    let slug: string;
+    try {
+      slug = sanitizeSlug(args.slug);
+    } catch (error) {
+      fail(
+        "INVALID_ARGUMENT",
+        error instanceof Error ? error.message : "invalid affiliate",
+      );
+    }
+    const name = cleanString(args.name, 120);
+    if (!name) fail("INVALID_ARGUMENT", "affiliate name is required");
+
+    const existingBySlug = await ctx.db
+      .query("affiliates")
+      .withIndex("by_siteId_and_slug", (range) =>
+        range.eq("siteId", args.siteId).eq("slug", slug),
+      )
+      .unique();
+    const affiliateId = args.affiliateId ?? existingBySlug?._id;
+    if (args.affiliateId && existingBySlug && existingBySlug._id !== args.affiliateId) {
+      fail("CONFLICT", "another affiliate already uses this slug");
+    }
+    const now = Date.now();
+    if (affiliateId) {
+      const affiliate = await ctx.db.get("affiliates", affiliateId);
+      if (!affiliate || affiliate.siteId !== args.siteId) {
+        fail("NOT_FOUND", "affiliate not found");
+      }
+      await ctx.db.patch("affiliates", affiliateId, {
+        slug,
+        name,
+        commissionBps: args.commissionBps,
+        attributionWindowDays: args.attributionWindowDays,
+        active: args.active ?? affiliate.active,
+        updatedAt: now,
+      });
+      return affiliateId;
+    }
+
+    const affiliates = await ctx.db
+      .query("affiliates")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .take(MAX_AFFILIATES_PER_SITE + 1);
+    if (affiliates.length >= MAX_AFFILIATES_PER_SITE) {
+      fail("LIMIT_EXCEEDED", "affiliate limit reached", {
+        limit: MAX_AFFILIATES_PER_SITE,
+      });
+    }
+    return await ctx.db.insert("affiliates", {
+      siteId: args.siteId,
+      slug,
+      name,
+      commissionBps: args.commissionBps,
+      attributionWindowDays: args.attributionWindowDays,
+      active: args.active ?? true,
+      createdAt: now,
+      updatedAt: now,
+    });
+  },
+});
+
+export const list = query({
+  args: { siteId: v.id("sites") },
+  returns: v.array(affiliateDocumentValidator),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("affiliates")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .take(MAX_AFFILIATES_PER_SITE);
+  },
+});
+
+export const remove = mutation({
+  args: { siteId: v.id("sites"), affiliateId: v.id("affiliates") },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const affiliate = await ctx.db.get("affiliates", args.affiliateId);
+    if (!affiliate || affiliate.siteId !== args.siteId) {
+      fail("NOT_FOUND", "affiliate not found");
+    }
+    await ctx.db.delete("affiliates", args.affiliateId);
+    return null;
+  },
+});

package/src/component/constants.ts

@@ -0,0 +1,28 @@
+export const MAX_BATCH_EVENTS = 20;
+export const MAX_BATCH_BYTES = 64 * 1024;
+export const MAX_EVENTS_PER_SESSION_WINDOW = 120;
+export const RATE_LIMIT_WINDOW_MS = 60_000;
+export const MAX_BYTES_PER_SESSION_WINDOW = 256 * 1024;
+export const SITE_INGEST_SHARDS = 8;
+export const MAX_SITE_EVENTS_PER_SHARD_WINDOW = 120;
+export const MAX_SITE_BYTES_PER_SHARD_WINDOW = 512 * 1024;
+export const LIVE_SESSION_TTL_MS = 60_000;
+export const AGGREGATE_SHARDS = 16;
+export const DIMENSION_SLOTS = 16;
+export const MAX_SITE_DOMAINS = 32;
+export const MAX_SITES_PER_OWNER = 100;
+export const MAX_GOALS_PER_SITE = 50;
+export const MAX_FUNNELS_PER_SITE = 20;
+export const MAX_AFFILIATES_PER_SITE = 100;
+export const MAX_FUNNEL_STEPS = 10;
+export const MAX_PROPERTIES = 16;
+export const MAX_REPORT_SITES = 10;
+export const MAX_REPORT_RANGE_DAYS = 366;
+export const MAX_LIVE_VISITORS = 500;
+export const MAX_JOURNEY_EVENTS = 500;
+export const MAX_RETENTION_BATCH = 500;
+export const MAX_OVERVIEW_AGGREGATE_ROWS = 12_000;
+
+export const DAY_MS = 86_400_000;
+export const HOUR_MS = 3_600_000;
+export const MAX_MANUAL_PAGINATION_OFFSET = 1_000;

package/src/component/convex.config.ts

@@ -0,0 +1,3 @@
+import { defineComponent } from "convex/server";
+
+export default defineComponent("rastroAnalytics");

package/src/component/errors.ts

@@ -0,0 +1,20 @@
+import { ConvexError } from "convex/values";
+
+export type RastroErrorCode =
+  | "NOT_FOUND"
+  | "INVALID_ARGUMENT"
+  | "INVALID_SITE"
+  | "ORIGIN_NOT_ALLOWED"
+  | "BATCH_TOO_LARGE"
+  | "LIMIT_EXCEEDED"
+  | "CONFLICT"
+  | "CURRENCY_MISMATCH"
+  | "RATE_LIMITED";
+
+export function fail(
+  code: RastroErrorCode,
+  message: string,
+  details?: Record<string, string | number | boolean | null>,
+): never {
+  throw new ConvexError({ code, message, details: details ?? null });
+}

package/src/component/funnels.ts

@@ -0,0 +1,134 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+import {
+  MAX_FUNNELS_PER_SITE,
+  MAX_FUNNEL_STEPS,
+} from "./constants.js";
+import { fail } from "./errors.js";
+import { cleanString, sanitizePath, sanitizeSlug } from "./sanitize.js";
+import {
+  funnelFieldsValidator,
+  funnelStepValidator,
+} from "./validators.js";
+
+const funnelDocumentValidator = funnelFieldsValidator.extend({
+  _id: v.id("funnels"),
+  _creationTime: v.number(),
+});
+
+export const upsert = mutation({
+  args: {
+    siteId: v.id("sites"),
+    funnelId: v.optional(v.id("funnels")),
+    key: v.string(),
+    name: v.string(),
+    steps: v.array(funnelStepValidator),
+    conversionWindowMs: v.number(),
+    active: v.optional(v.boolean()),
+  },
+  returns: v.id("funnels"),
+  handler: async (ctx, args) => {
+    if (!(await ctx.db.get("sites", args.siteId))) fail("NOT_FOUND", "site not found");
+    if (args.steps.length < 2 || args.steps.length > MAX_FUNNEL_STEPS) {
+      fail("INVALID_ARGUMENT", `funnels require 2-${MAX_FUNNEL_STEPS} steps`);
+    }
+    if (
+      !Number.isSafeInteger(args.conversionWindowMs) ||
+      args.conversionWindowMs < 60_000 ||
+      args.conversionWindowMs > 90 * 86_400_000
+    ) {
+      fail("INVALID_ARGUMENT", "conversionWindowMs must be between one minute and 90 days");
+    }
+    let key: string;
+    let steps: Array<{
+      type: "pageview" | "custom";
+      value: string;
+      name: string;
+    }>;
+    try {
+      key = sanitizeSlug(args.key, "key");
+      steps = args.steps.map((step) => {
+        const stepName = cleanString(step.name, 80);
+        const value = step.type === "pageview"
+          ? sanitizePath(step.value)
+          : cleanString(step.value, 80);
+        if (!stepName || !value) {
+          throw new Error("funnel steps require name and value");
+        }
+        return { type: step.type, value, name: stepName };
+      });
+    } catch (error) {
+      fail(
+        "INVALID_ARGUMENT",
+        error instanceof Error ? error.message : "invalid funnel",
+      );
+    }
+    const name = cleanString(args.name, 120);
+    if (!name) fail("INVALID_ARGUMENT", "funnel name is required");
+
+    const existingByKey = await ctx.db
+      .query("funnels")
+      .withIndex("by_siteId_and_key", (range) =>
+        range.eq("siteId", args.siteId).eq("key", key),
+      )
+      .unique();
+    const funnelId = args.funnelId ?? existingByKey?._id;
+    if (args.funnelId && existingByKey && existingByKey._id !== args.funnelId) {
+      fail("CONFLICT", "another funnel already uses this key");
+    }
+    const now = Date.now();
+    if (funnelId) {
+      const funnel = await ctx.db.get("funnels", funnelId);
+      if (!funnel || funnel.siteId !== args.siteId) fail("NOT_FOUND", "funnel not found");
+      await ctx.db.patch("funnels", funnelId, {
+        key,
+        name,
+        steps,
+        conversionWindowMs: args.conversionWindowMs,
+        active: args.active ?? funnel.active,
+        updatedAt: now,
+      });
+      return funnelId;
+    }
+
+    const funnels = await ctx.db
+      .query("funnels")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .take(MAX_FUNNELS_PER_SITE + 1);
+    if (funnels.length >= MAX_FUNNELS_PER_SITE) {
+      fail("LIMIT_EXCEEDED", "funnel limit reached", { limit: MAX_FUNNELS_PER_SITE });
+    }
+    return await ctx.db.insert("funnels", {
+      siteId: args.siteId,
+      key,
+      name,
+      steps,
+      conversionWindowMs: args.conversionWindowMs,
+      active: args.active ?? true,
+      createdAt: now,
+      updatedAt: now,
+    });
+  },
+});
+
+export const list = query({
+  args: { siteId: v.id("sites") },
+  returns: v.array(funnelDocumentValidator),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("funnels")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .take(MAX_FUNNELS_PER_SITE);
+  },
+});
+
+export const remove = mutation({
+  args: { siteId: v.id("sites"), funnelId: v.id("funnels") },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const funnel = await ctx.db.get("funnels", args.funnelId);
+    if (!funnel || funnel.siteId !== args.siteId) fail("NOT_FOUND", "funnel not found");
+    await ctx.db.delete("funnels", args.funnelId);
+    return null;
+  },
+});

package/src/component/goals.ts

@@ -0,0 +1,122 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+import { MAX_GOALS_PER_SITE } from "./constants.js";
+import { fail } from "./errors.js";
+import {
+  cleanString,
+  isValidMoney,
+  sanitizePath,
+  sanitizeSlug,
+} from "./sanitize.js";
+import {
+  goalFieldsValidator,
+  goalMatchTypeValidator,
+} from "./validators.js";
+
+const goalDocumentValidator = goalFieldsValidator.extend({
+  _id: v.id("goals"),
+  _creationTime: v.number(),
+});
+
+export const upsert = mutation({
+  args: {
+    siteId: v.id("sites"),
+    goalId: v.optional(v.id("goals")),
+    key: v.string(),
+    name: v.string(),
+    matchType: goalMatchTypeValidator,
+    matchValue: v.string(),
+    valueCents: v.optional(v.number()),
+    active: v.optional(v.boolean()),
+  },
+  returns: v.id("goals"),
+  handler: async (ctx, args) => {
+    if (!(await ctx.db.get("sites", args.siteId))) fail("NOT_FOUND", "site not found");
+    let key: string;
+    let matchValue: string;
+    try {
+      key = sanitizeSlug(args.key, "key");
+      matchValue = args.matchType === "pageview"
+        ? sanitizePath(args.matchValue)
+        : cleanString(args.matchValue, 80);
+    } catch (error) {
+      fail(
+        "INVALID_ARGUMENT",
+        error instanceof Error ? error.message : "invalid goal",
+      );
+    }
+    const name = cleanString(args.name, 120);
+    if (!name) fail("INVALID_ARGUMENT", "goal name is required");
+    if (!matchValue) fail("INVALID_ARGUMENT", "goal match value is required");
+    if (args.valueCents !== undefined && !isValidMoney(args.valueCents)) {
+      fail("INVALID_ARGUMENT", "valueCents must be an integer between 0 and 1000000000");
+    }
+
+    const existingByKey = await ctx.db
+      .query("goals")
+      .withIndex("by_siteId_and_key", (range) =>
+        range.eq("siteId", args.siteId).eq("key", key),
+      )
+      .unique();
+    const goalId = args.goalId ?? existingByKey?._id;
+    if (args.goalId && existingByKey && existingByKey._id !== args.goalId) {
+      fail("CONFLICT", "another goal already uses this key");
+    }
+    const now = Date.now();
+    if (goalId) {
+      const goal = await ctx.db.get("goals", goalId);
+      if (!goal || goal.siteId !== args.siteId) fail("NOT_FOUND", "goal not found");
+      await ctx.db.patch("goals", goalId, {
+        key,
+        name,
+        matchType: args.matchType,
+        matchValue,
+        valueCents: args.valueCents,
+        active: args.active ?? goal.active,
+        updatedAt: now,
+      });
+      return goalId;
+    }
+
+    const goals = await ctx.db
+      .query("goals")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .take(MAX_GOALS_PER_SITE + 1);
+    if (goals.length >= MAX_GOALS_PER_SITE) {
+      fail("LIMIT_EXCEEDED", "goal limit reached", { limit: MAX_GOALS_PER_SITE });
+    }
+    return await ctx.db.insert("goals", {
+      siteId: args.siteId,
+      key,
+      name,
+      matchType: args.matchType,
+      matchValue,
+      valueCents: args.valueCents,
+      active: args.active ?? true,
+      createdAt: now,
+      updatedAt: now,
+    });
+  },
+});
+
+export const list = query({
+  args: { siteId: v.id("sites") },
+  returns: v.array(goalDocumentValidator),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("goals")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .take(MAX_GOALS_PER_SITE);
+  },
+});
+
+export const remove = mutation({
+  args: { siteId: v.id("sites"), goalId: v.id("goals") },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const goal = await ctx.db.get("goals", args.goalId);
+    if (!goal || goal.siteId !== args.siteId) fail("NOT_FOUND", "goal not found");
+    await ctx.db.delete("goals", args.goalId);
+    return null;
+  },
+});

package/src/component/guards.ts

@@ -0,0 +1,3 @@
+export function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}