Renamed SchemaInterfaceIdentity to Identity

library/lens/lens.ts

@@ -7,9 +7,9 @@ import {
 import {
   type ExpandedSchema,
   expandSchema,
+  type Identity,
   type Schema,
   type SchemaInterface,
-  type SchemaInterfaceIdentity,
   type SchemaSearchInterface,
   type SchemaUpdateInterface,
 } from "../schema/mod.ts";
@@ -34,17 +34,17 @@ export const createLens = <T extends Schema>(
 ) => new Lens(schema, options);
 
 export class Lens<
-  S extends Schema,
-  I = SchemaInterface<S>,
-  U = SchemaUpdateInterface<S>,
-  X = SchemaSearchInterface<S>,
+  T extends Schema,
+  I = SchemaInterface<T>,
+  U = SchemaUpdateInterface<T>,
+  S = SchemaSearchInterface<T>,
 > {
   private readonly schema: ExpandedSchema;
   private readonly options: Options;
   private readonly engine: QueryEngineProxy;
   private readonly queryBuilder: QueryBuilder;
 
-  constructor(schema: S, options?: Options) {
+  constructor(schema: T, options?: Options) {
     this.schema = expandSchema(schema);
     this.options = resolveOptions(options);
     const context = resolveQueryContext(this.options);
@@ -74,7 +74,7 @@ export class Lens<
   }
 
   async find(
-    options: { where?: X | string | RDF.Quad[]; take?: number; skip?: number } =
+    options: { where?: S | string | RDF.Quad[]; take?: number; skip?: number } =
       {},
   ) {
     const { where, take, skip } = {
@@ -125,7 +125,7 @@ export class Lens<
     return this.updateQuery(q);
   }
 
-  delete(...identities: SchemaInterfaceIdentity[] | Iri[]) {
+  delete(...identities: Identity[] | Iri[]) {
     const iris = identities.map((identity) => {
       return typeof identity === "string" ? identity : identity.$id;
     });

library/lens/types.ts

@@ -1,8 +1,8 @@
-import type { SchemaInterfaceIdentity } from "../schema/mod.ts";
+import type { Identity } from "../schema/mod.ts";
 
 export type Entity<T extends unknown = Record<string, unknown>> =
   & DeepPartial<T>
-  & SchemaInterfaceIdentity;
+  & Identity;
 
 export type DeepPartial<T> = T extends Record<string, unknown>
   ? { [P in keyof T]?: DeepPartial<T[P]> }

library/schema/interface.ts

@@ -59,16 +59,12 @@ type ConvertProperty<T extends ValidPropertyDefinition> = T extends Property
   ? ConvertPropertyObject<T>
   : string;
 
-export type SchemaInterfaceIdentity = {
+export type Identity = {
   $id: string;
 };
 
-export type SchemaInterfaceType = {
-  $type: string[];
-};
-
 export type SchemaInterface<T extends Schema> =
-  & SchemaInterfaceIdentity
+  & Identity
   & {
     [X in Exclude<keyof T, "@type">]: T[X] extends ValidPropertyDefinition
       ? ConvertProperty<T[X]>
@@ -105,7 +101,7 @@ type ConvertUpdateProperty<T extends ValidPropertyDefinition> = T extends
   Property ? ConvertUpdatePropertyObject<T> : string;
 
 export type SchemaUpdateInterface<T extends Schema> =
-  & SchemaInterfaceIdentity
+  & Identity
   & {
     [X in Exclude<keyof T, "@type">]?: T[X] extends ValidPropertyDefinition
       ? ConvertUpdateProperty<T[X]>

library/schema/mod.ts

@@ -1,9 +1,8 @@
 export type { SupportedDataTypes, SupportedNativeTypes } from "./data_types.ts";
 
 export type {
+  Identity,
   SchemaInterface,
-  SchemaInterfaceIdentity,
-  SchemaInterfaceType,
   SchemaSearchInterface,
   SchemaUpdateInterface,
 } from "./interface.ts";

library/schema/schema.ts

@@ -12,16 +12,12 @@ export type Property = {
   "@inverse"?: true;
 };
 
-export type SchemaPrototypeProperties = {
-  [key: string]: Property | string | readonly string[];
-};
-
-export type SchemaPrototypeType = {
+export type Schema = {
   "@type"?: string | readonly string[];
+} & {
+  [key: string]: Property | string | readonly string[];
 };
 
-export type Schema = SchemaPrototypeProperties & SchemaPrototypeType;
-
 export type ExpandedProperty = {
   "@id": string;
   "@type"?: PropertyType;