@aromix/core 0.4.0 → 0.4.2

package/dist/index.d.ts

@@ -1,70 +1,84 @@
 import { AnySchema } from '@aromix/validator';
-import { Db, InsertOneOptions, InsertOneResult, BulkWriteOptions, InsertManyResult, Filter, FindOptions, UpdateFilter, UpdateOptions, UpdateResult, ReplaceOptions, DeleteOptions, DeleteResult, FindOneAndUpdateOptions, FindOneAndDeleteOptions, FindOneAndReplaceOptions, CountDocumentsOptions, DistinctOptions, AggregateOptions, AggregationCursor, BulkWriteResult, CreateIndexesOptions, DropIndexesOptions } from 'mongodb';
+import { Server } from 'http';
+import { Db, MongoClient } from 'mongodb';
+import { RedisClientType, RedisClusterType, RedisClientPoolType, RedisSentinelType } from 'redis';
 
-interface KvEntityUserInput<Schema extends AnySchema> {
+type MaybePromise<T> = T | Promise<T>
+
+interface Builder {
     name: string;
-    model: Schema;
+    onRegister?(state: Record<string, any>): MaybePromise<void>;
+    onListen?(server: Server): MaybePromise<void>;
+    onShutdown?(): MaybePromise<void>;
 }
-declare class KvEntity<Schema extends AnySchema> {
-    readonly state: KvEntityUserInput<Schema>;
-    private adapter;
-    constructor(userProvided: KvEntityUserInput<Schema>, internal: EntityBuilder.KvAdapter);
-    get(key: string): Promise<Schema['$select']>;
-    set(key: string, value: Schema['$insert']): Promise<void>;
-    delete(key: string): Promise<void>;
-    has(key: string): Promise<boolean>;
+declare function Builder(def: Builder): Builder;
+
+interface ValidateEnvConfig<Schema extends Record<string, AnySchema>> {
+    path: string;
+    schema: Schema;
+    onError?(err: unknown): void;
 }
+declare function ValidateEnv<const Schema extends Record<string, AnySchema>>(config: ValidateEnvConfig<Schema>): readonly [Builder, <Key extends keyof Schema>(key: Key, fallback?: Schema[Key]["$base"]) => Schema[Key]["$base"]];
 
-interface MongoEntityUserInput<Schema extends AnySchema> {
+interface EffectDef {
+    name: string;
+    run(): void;
+}
+declare function effect(def: EffectDef): EffectDef;
+
+interface GuardDef {
+    name: string;
+    run(): void;
+}
+declare function guard(def: GuardDef): GuardDef;
+
+declare class MongoDatabase {
+    db: Db;
+    constructor();
+    /** internal attach */
+    attach(db: Db): void;
+    entity<Schema extends AnySchema>(input: MongoEntityInput<Schema>): void;
+}
+
+type ClusterResult<T extends readonly string[]> = {
+    builder: Builder;
+    client: MongoClient;
+} & {
+    [K in T[number]]: MongoDatabase;
+};
+interface MongoClusterInput<Databases extends readonly string[]> {
+    name: string;
+    uri: string;
+    databases: Databases;
+    onConnect?(client: MongoClient): MaybePromise<void>;
+    onDisconnect?(client: MongoClient): MaybePromise<void>;
+    onError?(err: unknown): MaybePromise<void>;
+}
+interface MongoEntityInput<Schema extends AnySchema> {
     name: string;
     model: Schema;
 }
-declare class MongoEntity<Schema extends AnySchema> {
-    readonly states: MongoEntityUserInput<Schema>;
-    private readonly collection;
-    constructor(userInput: MongoEntityUserInput<Schema>, db: Db);
-    insertOne(doc: Schema['$insert'], options?: InsertOneOptions): Promise<InsertOneResult>;
-    insertMany(docs: Schema['$insert'][], options?: BulkWriteOptions): Promise<InsertManyResult>;
-    findOne(filter: Filter<Schema['$select']>, options?: FindOptions): Promise<Schema['$select'] | null>;
-    find(filter: Filter<Schema['$select']>, options?: FindOptions): Promise<Schema['$select'][]>;
-    updateOne(filter: Filter<Schema['$select']>, update: UpdateFilter<Schema['$update']>, options?: UpdateOptions): Promise<UpdateResult>;
-    updateMany(filter: Filter<Schema['$select']>, update: UpdateFilter<Schema['$update']>, options?: UpdateOptions): Promise<UpdateResult>;
-    replaceOne(filter: Filter<Schema['$select']>, replacement: Schema['$select'], options?: ReplaceOptions): Promise<UpdateResult>;
-    deleteOne(filter: Filter<Schema['$select']>, options?: DeleteOptions): Promise<DeleteResult>;
-    deleteMany(filter: Filter<Schema['$select']>, options?: DeleteOptions): Promise<DeleteResult>;
-    findOneAndUpdate(filter: Filter<Schema['$select']>, update: UpdateFilter<Schema['$update']>, options?: FindOneAndUpdateOptions): Promise<Schema['$select'] | null>;
-    findOneAndDelete(filter: Filter<Schema['$select']>, options?: FindOneAndDeleteOptions): Promise<Schema['$select'] | null>;
-    findOneAndReplace(filter: Filter<Schema['$select']>, replacement: Schema['$select'], options?: FindOneAndReplaceOptions): Promise<Schema['$select'] | null>;
-    countDocuments(filter: Filter<Schema['$select']>, options?: CountDocumentsOptions): Promise<number>;
-    estimatedDocumentCount(): Promise<number>;
-    distinct<Field extends keyof Schema['$select'] & string>(field: Field, filter: Filter<Schema['$select']>, options?: DistinctOptions): Promise<Array<Schema['$select'][Field]>>;
-    aggregate(pipeline: any[], options?: AggregateOptions): AggregationCursor;
-    bulkWrite(operations: any[], options?: BulkWriteOptions): Promise<BulkWriteResult>;
-    createIndex(indexSpec: any, options?: CreateIndexesOptions): Promise<string>;
-    dropIndex(indexName: string, options?: DropIndexesOptions): Promise<void>;
+
+declare function MongoCluster<const Databases extends readonly string[]>(options: MongoClusterInput<Databases>): ClusterResult<Databases>;
+
+type RedisAdapter = RedisClientType | RedisClusterType | RedisClientPoolType | RedisSentinelType;
+interface RedisInput {
+    name: string;
+    client(): RedisAdapter;
+    onConnect?(client: RedisAdapter): MaybePromise<void>;
+    onDisconnect?(client: RedisAdapter): MaybePromise<void>;
+    onError?(err: unknown): void;
+}
+declare class Redis {
+    constructor(input: RedisInput);
 }
 
-declare namespace EntityBuilder {
-    interface KvAdapter {
-        get(key: string): Promise<unknown>;
-        set(key: string, value: unknown): Promise<void>;
-        delete(key: string): Promise<void>;
-        has(key: string): Promise<boolean>;
-    }
-    interface KvInput {
-        transport: 'http';
-        adapter(): KvAdapter;
-    }
-    function kv(builderInput: KvInput): {
-        entity<Schema extends AnySchema>(entityInput: KvEntityUserInput<Schema>): KvEntity<Schema>;
-    };
-    interface MongoInput {
-        adapter(): Db;
-        transport: 'http';
-    }
-    function mongo(builderInput: MongoInput): {
-        entity<Schema extends AnySchema>(entityInput: MongoEntityUserInput<Schema>): MongoEntity<Schema>;
-    };
+declare class Application {
+    private state;
+    private builders;
+    register(builder: Builder): void;
+    listen(port: number): Promise<void>;
 }
+declare function bootstrap(): Application;
 
-export { EntityBuilder, KvEntity, type KvEntityUserInput, MongoEntity, type MongoEntityUserInput };
+export { Builder, type ClusterResult, type EffectDef, type GuardDef, type MaybePromise, MongoCluster, type MongoClusterInput, MongoDatabase, type MongoEntityInput, Redis, type RedisAdapter, type RedisInput, ValidateEnv, type ValidateEnvConfig, bootstrap, effect, guard };

package/dist/index.js

@@ -1,123 +1,123 @@
-// src/entity/platforms/kv.ts
-var KvEntity = class {
-  state;
-  adapter;
-  constructor(userProvided, internal) {
-    this.state = userProvided;
-    this.adapter = internal;
-  }
-  async get(key) {
-    const formattedKey = `${this.state.name}:${key}`;
-    const raw = await this.adapter.get(formattedKey);
-    return raw;
-  }
-  async set(key, value) {
-    const formattedKey = `${this.state.name}:${key}`;
-    await this.adapter.set(formattedKey, value);
-  }
-  async delete(key) {
-    const formattedKey = `${this.state.name}:${key}`;
-    await this.adapter.delete(formattedKey);
-  }
-  async has(key) {
-    const formattedKey = `${this.state.name}:${key}`;
-    return this.adapter.has(formattedKey);
-  }
-};
+// src/server/builder.ts
+function Builder(def) {
+  return def;
+}
 
-// src/entity/platforms/mongo.ts
-var MongoEntity = class {
-  states;
-  collection;
-  constructor(userInput, db) {
-    this.states = userInput;
-    this.collection = db.collection(userInput.name);
-  }
-  async insertOne(doc, options) {
-    return this.collection.insertOne(doc, options);
-  }
-  async insertMany(docs, options) {
-    return this.collection.insertMany(docs, options);
-  }
-  async findOne(filter, options) {
-    return this.collection.findOne(filter, options);
-  }
-  async find(filter, options) {
-    return this.collection.find(filter, options).toArray();
-  }
-  async updateOne(filter, update, options) {
-    return this.collection.updateOne(filter, update, options);
-  }
-  async updateMany(filter, update, options) {
-    return this.collection.updateMany(filter, update, options);
-  }
-  async replaceOne(filter, replacement, options) {
-    return this.collection.replaceOne(filter, replacement, options);
-  }
-  async deleteOne(filter, options) {
-    return this.collection.deleteOne(filter, options);
-  }
-  async deleteMany(filter, options) {
-    return this.collection.deleteMany(filter, options);
-  }
-  async findOneAndUpdate(filter, update, options) {
-    return this.collection.findOneAndUpdate(filter, update, options);
-  }
-  async findOneAndDelete(filter, options) {
-    return this.collection.findOneAndDelete(filter, options);
-  }
-  async findOneAndReplace(filter, replacement, options) {
-    return this.collection.findOneAndReplace(filter, replacement, options);
-  }
-  async countDocuments(filter, options) {
-    return this.collection.countDocuments(filter, options);
-  }
-  async estimatedDocumentCount() {
-    return this.collection.estimatedDocumentCount();
-  }
-  async distinct(field, filter, options) {
-    return this.collection.distinct(field, filter, options);
-  }
-  aggregate(pipeline, options) {
-    return this.collection.aggregate(pipeline, options);
-  }
-  async bulkWrite(operations, options) {
-    return this.collection.bulkWrite(operations, options);
+// src/common/validate.env.ts
+import { loadEnvFile } from "process";
+function ValidateEnv(config) {
+  const builder = Builder({
+    name: "validate.env",
+    onRegister(state) {
+      loadEnvFile(config.path);
+      console.log(state);
+      console.log(process.env);
+    }
+  });
+  function env(key, fallback) {
+    return process.env[key] ?? fallback;
+  }
+  return [builder, env];
+}
+
+// src/layer/effect.ts
+function effect(def) {
+  return def;
+}
+
+// src/layer/guard.ts
+function guard(def) {
+  return def;
+}
+
+// src/mongo/cluster.ts
+import { MongoClient } from "mongodb";
+
+// src/mongo/database.ts
+var MongoDatabase = class {
+  db;
+  constructor() {
   }
-  async createIndex(indexSpec, options) {
-    return this.collection.createIndex(indexSpec, options);
+  /** internal attach */
+  attach(db) {
+    this.db = db;
   }
-  async dropIndex(indexName, options) {
-    return this.collection.dropIndex(indexName, options);
+  entity(input) {
   }
 };
 
-// src/entity/builder.ts
-var EntityBuilder;
-((EntityBuilder2) => {
-  function kv(builderInput) {
-    const adapter = builderInput.adapter();
-    const result = {
-      entity(entityInput) {
-        return new KvEntity(entityInput, adapter);
+// src/mongo/cluster.ts
+function MongoCluster(options) {
+  const client = new MongoClient(options.uri);
+  const databases = {};
+  for (const name of options.databases) {
+    databases[name] = new MongoDatabase();
+  }
+  const builder = Builder({
+    name: options.name,
+    async onListen() {
+      try {
+        await client.connect();
+        for (const name of options.databases) {
+          const db = client.db(name);
+          databases[name].attach(db);
+        }
+        await options.onConnect?.(client);
+      } catch (err) {
+        await options.onError?.(err);
+        throw err;
       }
-    };
-    return result;
+    },
+    async onShutdown() {
+      await options.onDisconnect?.(client);
+      await client.close();
+    }
+  });
+  return {
+    client,
+    builder,
+    ...databases
+  };
+}
+
+// src/redis/redis.ts
+var Redis = class {
+  constructor(input) {
   }
-  EntityBuilder2.kv = kv;
-  function mongo(builderInput) {
-    const db = builderInput.adapter();
-    const result = {
-      entity(entityInput) {
-        return new MongoEntity(entityInput, db);
+};
+
+// src/server/application.ts
+import { createServer } from "http";
+var Application = class {
+  state = {};
+  builders = [];
+  register(builder) {
+    this.builders.push(builder);
+    builder.onRegister?.(this.state);
+  }
+  async listen(port) {
+    const server = createServer();
+    for (const builder of this.builders) {
+      await builder.onListen?.(server);
+    }
+    server.listen(port);
+    server.on("close", async () => {
+      for (const builder of this.builders) {
+        await builder.onShutdown?.();
       }
-    };
-    return result;
+    });
   }
-  EntityBuilder2.mongo = mongo;
-})(EntityBuilder || (EntityBuilder = {}));
+};
+function bootstrap() {
+  return new Application();
+}
 export {
-  EntityBuilder,
-  KvEntity,
-  MongoEntity
+  Builder,
+  MongoCluster,
+  MongoDatabase,
+  Redis,
+  ValidateEnv,
+  bootstrap,
+  effect,
+  guard
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aromix/core",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "The Core Package For Aromix",
   "type": "module",
   "license": "MIT",
@@ -18,9 +18,8 @@
     "core",
     "server",
     "framework",
-    "runtime-agnostic",
-    "deno",
-    "node"
+    "node",
+    "rpc"
   ],
   "files": [
     "dist"
@@ -42,18 +41,23 @@
   },
   "peerDependencies": {
     "@aromix/validator": "^0.3.0",
-    "mongodb": "^7.3.0"
+    "mongodb": "^7.3.0",
+    "redis": "^6.0.1"
   },
   "devDependencies": {
     "@aromix/validator": "^0.3.0",
     "@types/node": "^22.10.2",
     "mongodb": "^7.3.0",
+    "redis": "^6.0.1",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2"
   },
   "peerDependenciesMeta": {
     "mongodb": {
       "optional": true
+    },
+    "redis": {
+      "optional": true
     }
   }
 }