@sylphx/lens-solid 2.2.4 → 2.2.6

package/dist/index.js

@@ -5,7 +5,450 @@ var DSL_MARKER = Symbol("reify");
 // ../../node_modules/.bun/@sylphx+reify-core@0.1.2/node_modules/@sylphx/reify-core/dist/evaluator.js
 var plugins = new Map;
 // ../core/dist/index.js
+class FieldType {
+  _nullable = false;
+  _optional = false;
+  _default;
+  _resolutionMode = "exposed";
+  _resolver;
+  _subscriptionResolver;
+  nullable() {
+    const clone = Object.create(this);
+    clone._nullable = true;
+    return clone;
+  }
+  optional() {
+    const clone = Object.create(this);
+    clone._optional = true;
+    return clone;
+  }
+  default(value) {
+    const clone = Object.create(this);
+    clone._default = value;
+    return clone;
+  }
+  isNullable() {
+    return this._nullable;
+  }
+  isOptional() {
+    return this._optional;
+  }
+  getDefault() {
+    return this._default;
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return value;
+  }
+  resolve(fn) {
+    const clone = Object.create(this);
+    clone._resolutionMode = "resolve";
+    clone._resolver = fn;
+    return clone;
+  }
+  subscribe(fn) {
+    const clone = Object.create(this);
+    clone._resolutionMode = "subscribe";
+    clone._subscriptionResolver = fn;
+    return clone;
+  }
+  hasResolver() {
+    return this._resolutionMode === "resolve" && this._resolver !== undefined;
+  }
+  hasSubscription() {
+    return this._resolutionMode === "subscribe" && this._subscriptionResolver !== undefined;
+  }
+  getResolutionMode() {
+    return this._resolutionMode;
+  }
+}
+
+class IdType extends FieldType {
+  _type = "id";
+  _tsType;
+}
+
+class StringType extends FieldType {
+  _type = "string";
+  _tsType;
+}
+
+class IntType extends FieldType {
+  _type = "int";
+  _tsType;
+}
+
+class FloatType extends FieldType {
+  _type = "float";
+  _tsType;
+}
+
+class BooleanType extends FieldType {
+  _type = "boolean";
+  _tsType;
+}
+
+class DateTimeType extends FieldType {
+  _type = "datetime";
+  _tsType;
+  serialize(value) {
+    if (!(value instanceof Date)) {
+      throw new Error(`Expected Date instance, got ${typeof value}`);
+    }
+    return value.toISOString();
+  }
+  deserialize(value) {
+    if (typeof value !== "string") {
+      throw new Error(`Expected string, got ${typeof value}`);
+    }
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+      throw new Error(`Invalid date string: ${value}`);
+    }
+    return date;
+  }
+  validate(value) {
+    return value instanceof Date && !Number.isNaN(value.getTime());
+  }
+}
+
+class DecimalType extends FieldType {
+  _type = "decimal";
+  _tsType;
+  serialize(value) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      throw new Error(`Expected number, got ${typeof value}`);
+    }
+    return value.toString();
+  }
+  deserialize(value) {
+    if (typeof value !== "string") {
+      throw new Error(`Expected string, got ${typeof value}`);
+    }
+    const num = Number.parseFloat(value);
+    if (Number.isNaN(num)) {
+      throw new Error(`Invalid decimal string: ${value}`);
+    }
+    return num;
+  }
+  validate(value) {
+    return typeof value === "number" && !Number.isNaN(value) && Number.isFinite(value);
+  }
+}
+
+class DateType extends FieldType {
+  _type = "date";
+  _tsType;
+  serialize(value) {
+    if (!(value instanceof Date)) {
+      throw new Error(`Expected Date instance, got ${typeof value}`);
+    }
+    return value.toISOString().split("T")[0];
+  }
+  deserialize(value) {
+    if (typeof value !== "string") {
+      throw new Error(`Expected string, got ${typeof value}`);
+    }
+    const date = new Date(`${value}T00:00:00.000Z`);
+    if (Number.isNaN(date.getTime())) {
+      throw new Error(`Invalid date string: ${value}`);
+    }
+    return date;
+  }
+  validate(value) {
+    return value instanceof Date && !Number.isNaN(value.getTime());
+  }
+}
+
+class BigIntType extends FieldType {
+  _type = "bigint";
+  _tsType;
+  serialize(value) {
+    if (typeof value !== "bigint") {
+      throw new Error(`Expected bigint, got ${typeof value}`);
+    }
+    return value.toString();
+  }
+  deserialize(value) {
+    if (typeof value !== "string") {
+      throw new Error(`Expected string, got ${typeof value}`);
+    }
+    try {
+      return BigInt(value);
+    } catch {
+      throw new Error(`Invalid bigint string: ${value}`);
+    }
+  }
+  validate(value) {
+    return typeof value === "bigint";
+  }
+}
+
+class BytesType extends FieldType {
+  _type = "bytes";
+  _tsType;
+  serialize(value) {
+    if (!(value instanceof Uint8Array)) {
+      throw new Error(`Expected Uint8Array, got ${typeof value}`);
+    }
+    if (typeof btoa === "function") {
+      return btoa(String.fromCharCode(...value));
+    }
+    return Buffer.from(value).toString("base64");
+  }
+  deserialize(value) {
+    if (typeof value !== "string") {
+      throw new Error(`Expected string, got ${typeof value}`);
+    }
+    if (typeof atob === "function") {
+      const binary = atob(value);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0;i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+      }
+      return bytes;
+    }
+    return new Uint8Array(Buffer.from(value, "base64"));
+  }
+  validate(value) {
+    return value instanceof Uint8Array;
+  }
+}
+
+class JsonType extends FieldType {
+  _type = "json";
+  _tsType;
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return value;
+  }
+}
+
+class EnumType extends FieldType {
+  values;
+  _type = "enum";
+  _tsType;
+  constructor(values) {
+    super();
+    this.values = values;
+  }
+}
+
+class ObjectType extends FieldType {
+  _type = "object";
+  _tsType;
+}
+
+class ArrayType extends FieldType {
+  itemType;
+  _type = "array";
+  _tsType;
+  constructor(itemType) {
+    super();
+    this.itemType = itemType;
+  }
+}
+
+class CustomType extends FieldType {
+  definition;
+  _type = "custom";
+  _tsType;
+  constructor(definition) {
+    super();
+    this.definition = definition;
+  }
+  serialize(value) {
+    if (this.definition.validate && !this.definition.validate(value)) {
+      throw new Error(`Validation failed for custom type: ${this.definition.name}`);
+    }
+    return this.definition.serialize(value);
+  }
+  deserialize(value) {
+    return this.definition.deserialize(value);
+  }
+  validate(value) {
+    return this.definition.validate ? this.definition.validate(value) : true;
+  }
+}
+class HasOneType extends FieldType {
+  target;
+  foreignKey;
+  _type = "hasOne";
+  _tsType;
+  _relationKind = "hasOne";
+  constructor(target, foreignKey) {
+    super();
+    this.target = target;
+    this.foreignKey = foreignKey;
+  }
+}
+
+class HasManyType extends FieldType {
+  target;
+  foreignKey;
+  _type = "hasMany";
+  _tsType;
+  _relationKind = "hasMany";
+  constructor(target, foreignKey) {
+    super();
+    this.target = target;
+    this.foreignKey = foreignKey;
+  }
+}
+
+class BelongsToType extends FieldType {
+  target;
+  foreignKey;
+  _type = "belongsTo";
+  _tsType;
+  _relationKind = "belongsTo";
+  constructor(target, foreignKey) {
+    super();
+    this.target = target;
+    this.foreignKey = foreignKey;
+  }
+}
+
+class LazyOneType extends FieldType {
+  targetRef;
+  _type = "lazyOne";
+  _tsType;
+  _relationKind = "one";
+  constructor(targetRef) {
+    super();
+    this.targetRef = targetRef;
+  }
+  getTarget() {
+    return this.targetRef();
+  }
+}
+
+class LazyManyType extends FieldType {
+  targetRef;
+  _type = "lazyMany";
+  _tsType;
+  _relationKind = "many";
+  constructor(targetRef) {
+    super();
+    this.targetRef = targetRef;
+  }
+  getTarget() {
+    return this.targetRef();
+  }
+}
+var t = {
+  id: () => new IdType,
+  string: () => new StringType,
+  int: () => new IntType,
+  float: () => new FloatType,
+  boolean: () => new BooleanType,
+  datetime: () => new DateTimeType,
+  date: () => new DateType,
+  decimal: () => new DecimalType,
+  bigint: () => new BigIntType,
+  bytes: () => new BytesType,
+  json: () => new JsonType,
+  enum: (values) => new EnumType(values),
+  object: () => new ObjectType,
+  array: (itemType) => new ArrayType(itemType),
+  custom: (definition) => new CustomType(definition),
+  hasOne: (target) => new HasOneType(target),
+  hasMany: (target) => new HasManyType(target),
+  belongsTo: (target) => new BelongsToType(target),
+  one: (targetRef) => new LazyOneType(targetRef),
+  many: (targetRef) => new LazyManyType(targetRef)
+};
+function createContextualField(field) {
+  const wrapper = {
+    field,
+    resolve(fn) {
+      return field.resolve(fn);
+    },
+    subscribe(fn) {
+      return field.subscribe(fn);
+    },
+    nullable() {
+      return createContextualField(field.nullable());
+    },
+    optional() {
+      return createContextualField(field.optional());
+    },
+    default(value) {
+      return createContextualField(field.default(value));
+    }
+  };
+  return Object.assign(Object.create(field), wrapper);
+}
+function createTypeBuilder() {
+  return {
+    id: () => createContextualField(new IdType),
+    string: () => createContextualField(new StringType),
+    int: () => createContextualField(new IntType),
+    float: () => createContextualField(new FloatType),
+    boolean: () => createContextualField(new BooleanType),
+    datetime: () => createContextualField(new DateTimeType),
+    date: () => createContextualField(new DateType),
+    decimal: () => createContextualField(new DecimalType),
+    bigint: () => createContextualField(new BigIntType),
+    bytes: () => createContextualField(new BytesType),
+    json: () => createContextualField(new ObjectType),
+    enum: (values) => createContextualField(new EnumType(values)),
+    object: () => createContextualField(new ObjectType),
+    array: (itemType) => createContextualField(new ArrayType(itemType)),
+    custom: (definition) => createContextualField(new CustomType(definition)),
+    hasOne: (target) => createContextualField(new HasOneType(target)),
+    hasMany: (target) => createContextualField(new HasManyType(target)),
+    belongsTo: (target) => createContextualField(new BelongsToType(target)),
+    one: (targetRef) => createContextualField(new LazyOneType(targetRef)),
+    many: (targetRef) => createContextualField(new LazyManyType(targetRef))
+  };
+}
 var ENTITY_SYMBOL = Symbol("lens:entity");
+function defineEntity(nameOrFields, maybeFieldsOrBuilder) {
+  if (typeof nameOrFields === "object" && maybeFieldsOrBuilder === undefined) {
+    const fields2 = nameOrFields;
+    return createEntityDef(undefined, fields2);
+  }
+  const name = nameOrFields;
+  if (maybeFieldsOrBuilder === undefined) {
+    return new EntityBuilder_(name);
+  }
+  if (typeof maybeFieldsOrBuilder === "function") {
+    const builder = maybeFieldsOrBuilder;
+    const fields2 = builder(t);
+    return createEntityDef(name, fields2);
+  }
+  const fields = maybeFieldsOrBuilder;
+  return createEntityDef(name, fields);
+}
+function createEntityDef(name, fields) {
+  return {
+    [ENTITY_SYMBOL]: true,
+    _name: name,
+    fields,
+    "~entity": {
+      name,
+      type: undefined
+    }
+  };
+}
+var entity2 = Object.assign(defineEntity, (name) => new EntityBuilder_(name));
+
+class EntityBuilder_ {
+  _name;
+  constructor(_name) {
+    this._name = _name;
+  }
+  define(builder) {
+    const contextualBuilder = createTypeBuilder();
+    const fields = builder(contextualBuilder);
+    return createEntityDef(this._name, fields);
+  }
+}
 var OPTIMISTIC_PLUGIN_SYMBOL = Symbol.for("lens:optimistic-plugin");
 var DEFAULT_OPERATION_LOG_CONFIG = {
   maxEntries: 1e4,
@@ -979,8 +1422,8 @@ class SubscriptionRegistry {
       }
     }
   }
-  getByEntity(entity2, entityId) {
-    const entityKey = `${entity2}:${entityId}`;
+  getByEntity(entity3, entityId) {
+    const entityKey = `${entity3}:${entityId}`;
     const ids = this.entityIndex.get(entityKey);
     if (!ids)
       return [];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-solid",
-	"version": "2.2.4",
+	"version": "2.2.6",
 	"description": "SolidJS bindings for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -31,8 +31,8 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-client": "^2.4.2",
-		"@sylphx/lens-core": "^2.4.0"
+		"@sylphx/lens-client": "^2.4.4",
+		"@sylphx/lens-core": "^2.5.0"
 	},
 	"peerDependencies": {
 		"solid-js": ">=1.8.0"