convex-ents 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,293 @@
+import { DefineSchemaOptions, SchemaDefinition, GenericDocument, GenericTableIndexes, GenericTableSearchIndexes, GenericTableVectorIndexes, TableDefinition, SearchIndexConfig, VectorIndexConfig, GenericDataModel, DataModelFromSchemaDefinition } from 'convex/server';
+import { Validator, GenericId, PropertyValidators, ObjectType } from 'convex/values';
+
+declare function defineEntSchema<Schema extends Record<string, EntDefinition>, StrictTableNameTypes extends boolean = true>(schema: Schema, options?: DefineSchemaOptions<StrictTableNameTypes>): SchemaDefinition<Schema, StrictTableNameTypes>;
+declare function defineEnt<DocumentSchema extends Record<string, Validator<any, any, any>>>(documentSchema: DocumentSchema): EntDefinition<ExtractDocument<ObjectValidator<DocumentSchema>>, ExtractFieldPaths<ObjectValidator<DocumentSchema>>>;
+type GenericEdges = Record<string, GenericEdgeConfig>;
+type GenericEdgeConfig = {
+    name: string;
+    to: string;
+    cardinality: "single" | "multiple";
+    type: "field" | "ref";
+};
+interface EntDefinition<Document extends GenericDocument = GenericDocument, FieldPaths extends string = string, Indexes extends GenericTableIndexes = {}, SearchIndexes extends GenericTableSearchIndexes = {}, VectorIndexes extends GenericTableVectorIndexes = {}, Edges extends GenericEdges = {}> extends TableDefinition<Document, FieldPaths, Indexes, SearchIndexes, VectorIndexes> {
+    /**
+     * Define an index on this table.
+     *
+     * To learn about indexes, see [Defining Indexes](https://docs.convex.dev/using/indexes).
+     *
+     * @param name - The name of the index.
+     * @param fields - The fields to index, in order. Must specify at least one
+     * field.
+     * @returns A {@link TableDefinition} with this index included.
+     */
+    index<IndexName extends string, FirstFieldPath extends FieldPaths, RestFieldPaths extends FieldPaths[]>(name: IndexName, fields: [FirstFieldPath, ...RestFieldPaths]): EntDefinition<Document, FieldPaths, Expand<Indexes & Record<IndexName, [FirstFieldPath, ...RestFieldPaths, "_creationTime"]>>, SearchIndexes, VectorIndexes, Edges>;
+    /**
+     * Define a search index on this table.
+     *
+     * To learn about search indexes, see [Search](https://docs.convex.dev/text-search).
+     *
+     * @param name - The name of the index.
+     * @param indexConfig - The search index configuration object.
+     * @returns A {@link TableDefinition} with this search index included.
+     */
+    searchIndex<IndexName extends string, SearchField extends FieldPaths, FilterFields extends FieldPaths = never>(name: IndexName, indexConfig: Expand<SearchIndexConfig<SearchField, FilterFields>>): EntDefinition<Document, FieldPaths, Indexes, Expand<SearchIndexes & Record<IndexName, {
+        searchField: SearchField;
+        filterFields: FilterFields;
+    }>>, VectorIndexes, Edges>;
+    vectorIndex<IndexName extends string, VectorField extends FieldPaths, FilterFields extends FieldPaths = never>(name: IndexName, indexConfig: Expand<VectorIndexConfig<VectorField, FilterFields>>): EntDefinition<Document, FieldPaths, Indexes, SearchIndexes, Expand<VectorIndexes & Record<IndexName, {
+        vectorField: VectorField;
+        dimensions: number;
+        filterFields: FilterFields;
+    }>>, Edges>;
+    field<FieldName extends string, T extends Validator<any, any, any>>(field: FieldName, validator: T): EntDefinition<Document & ObjectFieldType<FieldName, T>, FieldPaths | FieldName, Indexes, SearchIndexes, VectorIndexes, Edges>;
+    field<FieldName extends string, T extends Validator<any, any, any>>(field: FieldName, validator: T, options: {
+        index: true;
+    }): EntDefinition<Document & ObjectFieldType<FieldName, T>, FieldPaths | FieldName, Indexes & {
+        [key in FieldName]: [FieldName];
+    }, SearchIndexes, VectorIndexes, Edges>;
+    field<FieldName extends string, T extends Validator<any, any, any>>(field: FieldName, validator: T, options: {
+        unique: true;
+    }): EntDefinition<Document & ObjectFieldType<FieldName, T>, FieldPaths | FieldName, Indexes & {
+        [key in FieldName]: [FieldName];
+    }, SearchIndexes, VectorIndexes, Edges>;
+    field<FieldName extends string, T extends Validator<any, false, any>>(field: FieldName, validator: T, options: {
+        default: T["type"];
+    }): EntDefinition<Document & ObjectFieldType<FieldName, T>, FieldPaths | FieldName, Indexes, SearchIndexes, VectorIndexes, Edges>;
+    edge<EdgeName extends string>(edge: EdgeName): EntDefinition<Document & {
+        [key in `${EdgeName}Id`]: GenericId<`${EdgeName}s`>;
+    }, FieldPaths | `${EdgeName}Id`, Indexes & {
+        [key in `${EdgeName}Id`]: [`${EdgeName}Id`];
+    }, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgeName]: {
+            name: EdgeName;
+            to: `${EdgeName}s`;
+            type: "field";
+            cardinality: "single";
+        };
+    }>;
+    edge<EdgeName extends string, const FieldName extends string>(edge: EdgeName, options: {
+        field: FieldName;
+    }): EntDefinition<Document & {
+        [key in NoInfer<FieldName>]: GenericId<`${EdgeName}s`>;
+    }, FieldPaths | NoInfer<FieldName>, Indexes & {
+        [key in NoInfer<FieldName>]: [NoInfer<FieldName>];
+    }, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgeName]: {
+            name: EdgeName;
+            to: `${EdgeName}s`;
+            type: "field";
+            cardinality: "single";
+        };
+    }>;
+    edge<EdgeName extends string, const FieldName extends string, const ToTable extends string>(edge: EdgeName, options: {
+        field: FieldName;
+        to: ToTable;
+    }): EntDefinition<Document & {
+        [key in NoInfer<FieldName>]: GenericId<ToTable>;
+    }, FieldPaths | NoInfer<FieldName>, Indexes & {
+        [key in NoInfer<FieldName>]: [NoInfer<FieldName>];
+    }, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgeName]: {
+            name: EdgeName;
+            to: ToTable;
+            type: "field";
+            cardinality: "single";
+        };
+    }>;
+    edge<EdgeName extends string>(edge: EdgeName, options: {
+        optional: true;
+        ref?: string;
+    }): EntDefinition<Document, FieldPaths, Indexes, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgeName]: {
+            name: EdgeName;
+            to: `${EdgeName}s`;
+            type: "ref";
+            cardinality: "single";
+        };
+    }>;
+    edge<EdgeName extends string, const ToTable extends string>(edge: EdgeName, options: {
+        optional: true;
+        to: ToTable;
+        ref?: string;
+    }): EntDefinition<Document, FieldPaths, Indexes, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgeName]: {
+            name: EdgeName;
+            to: NoInfer<ToTable>;
+            type: "ref";
+            cardinality: "single";
+        };
+    }>;
+    /**
+     * Define many:1 edge to another table.
+     * @param edge The name of the edge, also the name of the target table.
+     * @param options.ref The name of the field that stores the many:1 edge
+     *   on the other table, or `true` to infer it.
+     */
+    edges<EdgesName extends string>(edge: EdgesName, options: {
+        ref: true | string;
+    }): EntDefinition<Document, FieldPaths, Indexes, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgesName]: {
+            name: EdgesName;
+            to: EdgesName;
+            type: "field";
+            cardinality: "multiple";
+        };
+    }>;
+    /**
+     * Define many:1 edge to another table.
+     * @param edge The name of the edge.
+     * @param options.to Name of the table the edge points to.
+     *   If it's the same as the table this edge is defined on, this edge is
+     *   a symmetric, self-directed many:many edge.
+     * @param options.ref The name of the field that stores the many:1 edge
+     *   on the other table, or `true` to infer it.
+     */
+    edges<EdgesName extends string, TableName extends string>(edge: EdgesName, options: {
+        to: TableName;
+        ref: true | string;
+    }): EntDefinition<Document, FieldPaths, Indexes, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgesName]: {
+            name: EdgesName;
+            to: NoInfer<TableName>;
+            type: "field";
+            cardinality: "multiple";
+        };
+    }>;
+    /**
+     * Define many:many edge to another table.
+     * @param edge The name of the edge, also the name of the target table.
+     * @param options.table Optional, name of the table to store the many:many edge in.
+     * @param options.field Optional, name of the field to store the ID of the
+     *   this end of the many:many edge.
+     */
+    edges<EdgesName extends string>(edge: EdgesName, options?: {
+        table?: string;
+        field?: string;
+    }): EntDefinition<Document, FieldPaths, Indexes, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgesName]: {
+            name: EdgesName;
+            to: EdgesName;
+            type: "ref";
+            cardinality: "multiple";
+        };
+    }>;
+    /**
+     * Define many:many edge to another table.
+     * @param edge The name of the edge.
+     * @param options.to Name of the table the edge points to.
+     *   If it's the same as the table this edge is defined on, this edge is
+     *   a symmetric, self-directed many:many edge.
+     * @param options.table Optional, name of the table to store the many:many edge in.
+     * @param options.field Optional, name of the field to store the ID of the
+     *   of the source end of the forward many:many edge.
+     * @param options.inverseField Optional, name of the field to store the ID
+     *   of the target end of the forward edge. Only allowed for symmetric,
+     *   self-directed many:many edges.
+     */
+    edges<EdgesName extends string, TableName extends string>(edge: EdgesName, options: {
+        to: TableName;
+        table?: string;
+        field?: string;
+        inverseField?: string;
+    }): EntDefinition<Document, FieldPaths, Indexes, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgesName]: {
+            name: EdgesName;
+            to: NoInfer<TableName>;
+            type: "ref";
+            cardinality: "multiple";
+        };
+    }>;
+    /**
+     * Define self-directed, assymetric, many:many edge.
+     * @param edge The name of the edge.
+     * @param options.to Name of the table the edge points to.
+     *   Must be the same as the table this edge is defined on.
+     * @param options.inverse Name of the inverse edge.
+     * @param options.table Optional, name of the table to store the many:many edge in.
+     * @param options.field Optional, name of the field to store the ID of the
+     *   of the source end of the forward many:many edge.
+     * @param options.inverseField Optional, name of the field to store the ID
+     *   of the target end of the forward many:many edge.
+     */
+    edges<EdgesName extends string, TableName extends string, InverseEdgesNames extends string>(edge: EdgesName, options: {
+        to: TableName;
+        inverse: InverseEdgesNames;
+        table?: string;
+        field?: string;
+        inverseField?: string;
+    }): EntDefinition<Document, FieldPaths, Indexes, SearchIndexes, VectorIndexes, Edges & {
+        [key in EdgesName]: {
+            name: EdgesName;
+            to: NoInfer<TableName>;
+            type: "ref";
+            cardinality: "multiple";
+        };
+    } & {
+        [key in NoInfer<InverseEdgesNames>]: {
+            name: NoInfer<InverseEdgesNames>;
+            to: NoInfer<TableName>;
+            type: "ref";
+            cardinality: "multiple";
+        };
+    }>;
+}
+type NoInfer<T> = [T][T extends any ? 0 : never];
+type ObjectFieldType<FieldName extends string, T extends Validator<any, any, any>> = T["isOptional"] extends true ? {
+    [key in FieldName]?: T["type"];
+} : {
+    [key in FieldName]: T["type"];
+};
+type EdgeConfig = {
+    name: string;
+    to: string;
+} & (({
+    cardinality: "single";
+} & ({
+    type: "field";
+    field: string;
+    unique: boolean;
+} | {
+    type: "ref";
+    ref: string;
+})) | ({
+    cardinality: "multiple";
+} & ({
+    type: "field";
+    ref: string;
+} | {
+    type: "ref";
+    table: string;
+    field: string;
+    ref: string;
+    inverse: boolean;
+    symmetric: boolean;
+})));
+type FieldConfig = {
+    name: string;
+    unique: boolean;
+};
+type ExtractDocument<T extends Validator<any, any, any>> = Expand<SystemFields & T["type"]>;
+type Expand<ObjectType extends Record<any, any>> = ObjectType extends Record<any, any> ? {
+    [Key in keyof ObjectType]: ObjectType[Key];
+} : never;
+type ExtractFieldPaths<T extends Validator<any, any, any>> = T["fieldPaths"] | keyof SystemFields;
+type SystemFields = {
+    _creationTime: number;
+};
+type ObjectValidator<Validators extends PropertyValidators> = Validator<ObjectType<Validators>, false, {
+    [Property in keyof Validators]: JoinFieldPaths<Property & string, Validators[Property]["fieldPaths"]> | Property;
+}[keyof Validators] & string>;
+type JoinFieldPaths<Start extends string, End extends string> = `${Start}.${End}`;
+type GenericEntsDataModel = GenericDataModel & Record<string, GenericEntModel>;
+type GenericEntModel = {
+    edges: Record<string, GenericEdgeConfig>;
+};
+type EntDataModelFromSchema<SchemaDef extends SchemaDefinition<any, boolean>> = DataModelFromSchemaDefinition<SchemaDef> & {
+    [TableName in keyof SchemaDef["tables"] & string]: SchemaDef["tables"][TableName] extends EntDefinition<any, any, any, any, any, infer Edges> ? {
+        edges: Edges;
+    } : never;
+};
+declare function getEntDefinitions<SchemaDef extends SchemaDefinition<any, boolean>>(schema: SchemaDef): EntDataModelFromSchema<typeof schema>;
+
+export { type EdgeConfig, type EntDataModelFromSchema, type EntDefinition, type Expand, type FieldConfig, type GenericEdgeConfig, type GenericEntModel, type GenericEntsDataModel, type SystemFields, defineEnt, defineEntSchema, getEntDefinitions };

package/dist/schema.js

@@ -0,0 +1,325 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  defineEnt: () => defineEnt,
+  defineEntSchema: () => defineEntSchema,
+  getEntDefinitions: () => getEntDefinitions
+});
+module.exports = __toCommonJS(schema_exports);
+var import_server = require("convex/server");
+var import_values = require("convex/values");
+function defineEntSchema(schema, options) {
+  const tableNames = Object.keys(schema);
+  for (const tableName of tableNames) {
+    const table = schema[tableName];
+    for (const edge of edgeConfigsFromEntDefinition(table)) {
+      if (
+        // Skip inverse edges, we process their forward edges
+        edge.cardinality === "multiple" && edge.type === "ref" && edge.inverse !== void 0 || // symmetric is only set by defineEntSchema,
+        // so we already processed the pair
+        edge.symmetric !== void 0
+      ) {
+        continue;
+      }
+      const otherTableName = edge.to;
+      const otherTable = schema[otherTableName];
+      if (otherTable === void 0) {
+        throw new Error(
+          `Edge "${edge.name}" in table "${tableName}" points to an undefined table "${otherTableName}"`
+        );
+      }
+      const isSelfDirected = edge.to === tableName;
+      const inverseEdgeCandidates = edgeConfigsFromEntDefinition(
+        otherTable
+      ).filter(canBeInverseEdge(tableName, edge, isSelfDirected));
+      if (inverseEdgeCandidates.length > 1) {
+        throw new Error(
+          `Edge "${edge.name}" in table "${tableName}" has too many potential inverse edges in table "${otherTableName}": ${inverseEdgeCandidates.map((edge2) => `"${edge2.name}"`).join(", ")}`
+        );
+      }
+      const inverseEdge = inverseEdgeCandidates[0];
+      if (edge.cardinality === "single" && edge.type === "ref") {
+        if (inverseEdge === void 0) {
+          throw new Error(
+            `Missing inverse edge in table "${otherTableName}" ${edge.ref !== null ? `with field "${edge.ref}" ` : ""}for edge "${edge.name}" in table "${tableName}"`
+          );
+        }
+        if (inverseEdge.cardinality === "single" && inverseEdge.type === "ref") {
+          throw new Error(
+            `Both edge "${edge.name}" in table "${inverseEdge.to}" and edge "${inverseEdge.name}" in table "${edge.to}" are marked as optional, choose one to be required.`
+          );
+        }
+        if (inverseEdge.cardinality !== "single" || inverseEdge.type !== "field") {
+          throw new Error(
+            `Unexpected inverse edge type ${edge.name}, ${inverseEdge?.name}`
+          );
+        }
+        if (edge.ref === null) {
+          edge.ref = inverseEdge.field;
+        }
+        inverseEdge.unique = true;
+      }
+      if (edge.cardinality === "multiple") {
+        if (!isSelfDirected && inverseEdge === void 0) {
+          throw new Error(
+            `Missing inverse edge in table "${otherTableName}" for edge "${edge.name}" in table "${tableName}"`
+          );
+        }
+        if (inverseEdge?.cardinality === "single") {
+          if (inverseEdge.type === "ref") {
+            throw new Error(
+              `The edge "${inverseEdge.name}" in table "${otherTableName}" cannot be optional, as it must store the 1:many edge as a field. Check the its inverse edge "${edge.name}" in table "${tableName}".`
+            );
+          }
+          if (edge.type === "ref") {
+            throw new Error(
+              `The edge "${inverseEdge.name}" in table "${otherTableName}" cannot be singular, as the edge "${edge.name}" in table "${tableName}" did not specify the \`ref\` option.`
+            );
+          }
+          edge.type = "field";
+          edge.ref = inverseEdge.field;
+        }
+        if (inverseEdge?.cardinality === "multiple" || isSelfDirected) {
+          if (!isSelfDirected && edge?.type === "field") {
+            throw new Error(
+              `The edge "${edge.name}" in table "${tableName}" specified \`ref\`, but its inverse edge "${inverseEdge.name}" in table "${otherTableName}" is not the singular end of a 1:many edge.`
+            );
+          }
+          if (inverseEdge?.type === "field") {
+            throw new Error(
+              `The edge "${inverseEdge.name}" in table "${otherTableName}" specified \`ref\`, but its inverse edge "${edge.name}" in table "${tableName}" is not the singular end of a 1:many edge.`
+            );
+          }
+          const edgeTableName = edge.type === "ref" && edge.table !== void 0 ? edge.table : inverseEdge === void 0 ? `${tableName}_${edge.name}` : inverseEdge.name !== tableName ? `${tableName}_${inverseEdge.name}_to_${edge.name}` : `${inverseEdge.name}_to_${edge.name}`;
+          const forwardId = edge.type === "ref" && edge.field !== void 0 ? edge.field : inverseEdge === void 0 ? "aId" : tableName === otherTableName ? inverseEdge.name + "Id" : tableName + "Id";
+          const inverseId = isSelfDirected && edge.type === "ref" && edge.inverseField !== void 0 ? edge.inverseField : inverseEdge === void 0 ? "bId" : inverseEdge.type === "ref" && inverseEdge.field !== void 0 ? inverseEdge.field : tableName === otherTableName ? edge.name + "Id" : otherTableName + "Id";
+          schema[edgeTableName] = defineEnt({
+            [forwardId]: import_values.v.id(tableName),
+            [inverseId]: import_values.v.id(otherTableName)
+          }).index(forwardId, [forwardId, inverseId]).index(inverseId, [inverseId, forwardId]);
+          edge.type = "ref";
+          edge.table = edgeTableName;
+          edge.field = forwardId;
+          edge.ref = inverseId;
+          edge.symmetric = inverseEdge === void 0;
+          if (inverseEdge !== void 0) {
+            inverseEdge.type = "ref";
+            inverseEdge.table = edgeTableName;
+            inverseEdge.field = inverseId;
+            inverseEdge.ref = forwardId;
+            inverseEdge.symmetric = false;
+          }
+        }
+      }
+    }
+  }
+  return (0, import_server.defineSchema)(schema, options);
+}
+function canBeInverseEdge(tableName, edge, isSelfDirected) {
+  return (candidate) => {
+    if (candidate.to !== tableName) {
+      return false;
+    }
+    if (isSelfDirected) {
+      return candidate.cardinality === "multiple" && candidate.type === "ref" && candidate.inverse === edge.name;
+    }
+    if (edge.cardinality === "single" && edge.type === "ref" && edge.ref !== null || edge.cardinality === "multiple" && edge.type === "field" && edge.ref !== true) {
+      if (candidate.cardinality === "single" && candidate.type === "field") {
+        return edge.ref === candidate.field;
+      }
+    }
+    if (edge.cardinality === "single" && edge.type === "field" && edge.field !== null) {
+      if (candidate.cardinality === "single" && candidate.type === "ref" && candidate.ref !== null || candidate.cardinality === "multiple" && candidate.type === "field" && candidate.ref !== true) {
+        return edge.field === candidate.ref;
+      }
+    }
+    if (edge.cardinality === "multiple" && edge.type === "ref" && edge.table !== void 0) {
+      return candidate.cardinality === "multiple" && candidate.type === "ref" && edge.table === candidate.table;
+    }
+    if (candidate.cardinality === "multiple" && candidate.type === "ref" && candidate.table !== void 0) {
+      return edge.cardinality === "multiple" && edge.type === "ref" && edge.table === candidate.table;
+    }
+    return true;
+  };
+}
+function edgeConfigsFromEntDefinition(table) {
+  return Object.values(
+    table.edgeConfigs
+  );
+}
+function defineEnt(documentSchema) {
+  return new EntDefinitionImpl(documentSchema);
+}
+var EntDefinitionImpl = class {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  indexes = [];
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  searchIndexes = [];
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  vectorIndexes = [];
+  documentSchema;
+  edgeConfigs = {};
+  fieldConfigs = {};
+  defaults = {};
+  constructor(documentSchema) {
+    this.documentSchema = documentSchema;
+  }
+  index(name, fields) {
+    this.indexes.push({ indexDescriptor: name, fields });
+    return this;
+  }
+  searchIndex(name, indexConfig) {
+    this.searchIndexes.push({
+      indexDescriptor: name,
+      searchField: indexConfig.searchField,
+      filterFields: indexConfig.filterFields || []
+    });
+    return this;
+  }
+  vectorIndex(name, indexConfig) {
+    this.vectorIndexes.push({
+      indexDescriptor: name,
+      vectorField: indexConfig.vectorField,
+      dimensions: indexConfig.dimensions,
+      filterFields: indexConfig.filterFields || []
+    });
+    return this;
+  }
+  /**
+   * Export the contents of this definition.
+   *
+   * This is called internally by the Convex framework.
+   * @internal
+   */
+  export() {
+    return {
+      indexes: this.indexes,
+      searchIndexes: this.searchIndexes,
+      vectorIndexes: this.vectorIndexes,
+      documentType: import_values.v.object(this.documentSchema).json
+    };
+  }
+  field(name, validator, options) {
+    if (this.documentSchema[name] !== void 0) {
+      throw new Error(`Duplicate field "${name}"`);
+    }
+    const finalValidator = options?.default !== void 0 ? import_values.v.optional(validator) : validator;
+    this.documentSchema = { ...this.documentSchema, [name]: finalValidator };
+    if (options?.unique === true || options?.index === true) {
+      this.indexes.push({ indexDescriptor: name, fields: [name] });
+    }
+    if (options?.default !== void 0) {
+      this.defaults[name] = options.default;
+    }
+    if (options?.unique === true) {
+      this.fieldConfigs[name] = { name, unique: true };
+    }
+    return this;
+  }
+  edge(edgeName, options) {
+    if (this.edgeConfigs[edgeName] !== void 0) {
+      throw new Error(`Duplicate edge "${edgeName}"`);
+    }
+    const to = options?.to ?? edgeName + "s";
+    if (options?.optional !== true) {
+      const fieldName = options?.field ?? edgeName + "Id";
+      this.documentSchema = { ...this.documentSchema, [fieldName]: import_values.v.id(to) };
+      this.edgeConfigs[edgeName] = {
+        name: edgeName,
+        to,
+        cardinality: "single",
+        type: "field",
+        field: fieldName
+      };
+      this.indexes.push({
+        indexDescriptor: fieldName,
+        fields: [fieldName]
+      });
+      return this;
+    }
+    if (options.optional === true) {
+      this.edgeConfigs[edgeName] = {
+        name: edgeName,
+        to,
+        cardinality: "single",
+        type: "ref",
+        ref: options.ref ?? null
+      };
+    }
+    return this;
+  }
+  edges(name, options) {
+    const cardinality = "multiple";
+    const to = options?.to ?? name;
+    const ref = options?.ref;
+    const table = options?.table;
+    if (ref !== void 0 && table !== void 0) {
+      throw new Error(
+        `Cannot specify both \`ref\` and \`table\` for the same edge, as the former is for 1:many edges and the latter for many:many edges. Config: \`${JSON.stringify(options)}\``
+      );
+    }
+    const field = options?.field;
+    const inverseField = options?.inverseField;
+    if ((field !== void 0 || inverseField !== void 0) && table === void 0) {
+      throw new Error(
+        `Specify \`table\` if you're customizing the \`field\` or \`inverseField\` for a many:many edge. Config: \`${JSON.stringify(options)}\``
+      );
+    }
+    const inverseName = options?.inverse;
+    this.edgeConfigs[name] = ref !== void 0 ? { name, to, cardinality, type: "field", ref } : { name, to, cardinality, type: "ref", table, field, inverseField };
+    if (inverseName !== void 0) {
+      this.edgeConfigs[inverseName] = {
+        name: inverseName,
+        to,
+        cardinality,
+        type: "ref",
+        inverse: name,
+        table
+      };
+    }
+    return this;
+  }
+};
+function getEntDefinitions(schema) {
+  const tables = schema.tables;
+  return Object.keys(tables).reduce(
+    (acc, tableName) => ({
+      ...acc,
+      [tableName]: {
+        defaults: tables[tableName].defaults,
+        edges: tables[tableName].edgeConfigs,
+        fields: tables[tableName].fieldConfigs
+      }
+    }),
+    {}
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineEnt,
+  defineEntSchema,
+  getEntDefinitions
+});
+//# sourceMappingURL=schema.js.map