* step 1

* Refactorings

* command modules do not depend on anything but itself

* tearing it up

* Remove module store, manager, and Intializable type

* consolidate interfaces in single file

* consolidate default services in single file

* TEAR IT UP

* fix text compile

* the end of sern init??

* Presence namespaced types removed

* internal namespace

* clean up dependencies

* fix test

* fix circular dependency

* still broken but progress

* remove barrel for core/structs

* reffactor

* refactor allat

* more refactoring

* prototyping linking static handler

* cleanup tests, codegen, and importing handler

* some refactor

* generify partition

* for now copy paste new ioc system

* removeiti

* fdsfD

* ensure container is init'd

* fix absPath gen

* working on bun compat

* refactor and clean up and reenter v3 module loading

* dsfsd

* refactor, add cron types, reinstante module loader

* ready handler revamped so much cleaner

* fdssdf

* refactor deps list

* add more tests, polish up ioc

* up to speed with event modules

* i think cron works

* cron works now, poc

* ksdjkldsfld

* updating ioc api, experimenting with cron

* save b4 thunder and lightning

* plugin data reduction & args changes

* freeze module after plugins, updateModule, and more

* simplify plugin args and prepare for reduction among plugins

* add deps to plugin calls and execute

* plugin system loking better, tbd type

* porg

* initplugins inject deps, inconspicuos

* fix faiklling test

* fix initPlugins not reassigning

* parsingParams kinda

* proper mapping

* dynamic customIds

* handling customId params working

* testing n shi

* inlineinignsd

* consolidate fmt

* once on eventModules

* refact,simplf

* readd vitest and Asset fn

* fix typings

* assets fn complete

* more intuitive context.options and Asset typings

* add init hooks not firing

* -file,-updateModule,publish?

* fix: ioc deps not created correctly

* documentation, add json for Asset

* remove asset

* ss

* finish ioc transition

* nvm, now i did

* s

* update locals api, docs, tests

* fix tests

* fix up tests and cleanup

* fix

* Update src/core/functions.ts

Co-authored-by: Evo <85353424+EvolutionX-10@users.noreply.github.com>

* better documentation

* temp fix

* namespace presence types again

* revising cron modules and better error messages

* scheduler ids

* more descriptive errors

* refactor to not type leak and job cancellation

* refactor n better signatures for task scheduler

* documentation

* fix swap not accepting functions

* change task signature

---------

Co-authored-by: Evo <85353424+EvolutionX-10@users.noreply.github.com>
This commit is contained in:
Jacob Nguyen
2024-07-18 16:54:55 -05:00
committed by GitHub
parent 04c4625bfa
commit 9a8904f5ae
75 changed files with 2481 additions and 3672 deletions

View File

@@ -1,23 +1,26 @@
import { type Observable, from, mergeMap, ObservableInput } from 'rxjs';
import { readdir, stat } from 'fs/promises';
import { basename, extname, join, resolve, parse, dirname } from 'path';
import assert from 'assert';
import { createRequire } from 'node:module';
import type { ImportPayload, Wrapper } from '../types/core';
import type { Module } from '../types/core-modules';
import { existsSync } from 'fs';
import type { Logging } from './contracts/logging';
import path from 'node:path';
import { existsSync } from 'node:fs';
import { readdir } from 'fs/promises';
import assert from 'node:assert';
import * as Id from './id'
import { Module } from '../types/core-modules';
export const shouldHandle = (path: string, fpath: string) => {
const file_name = fpath+extname(path);
let newPath = join(dirname(path), file_name)
.replace(/file:\\?/, "");
return { exists: existsSync(newPath),
path: 'file:///'+newPath };
export const parseCallsite = (site: string) => {
const pathobj = path.posix.parse(site.replace(/file:\\?/, "")
.split(path.sep)
.join(path.posix.sep))
return { name: pathobj.name,
absPath : path.posix.format(pathobj) }
}
export const shouldHandle = (pth: string, filenam: string) => {
const file_name = filenam+path.extname(pth);
let newPath = path.join(path.dirname(pth), file_name)
.replace(/file:\\?/, "");
return { exists: existsSync(newPath),
path: 'file://'+newPath };
}
export type ModuleResult<T> = Promise<ImportPayload<T>>;
/**
* Import any module based on the absolute path.
@@ -25,7 +28,6 @@ export type ModuleResult<T> = Promise<ImportPayload<T>>;
* commonjs, javascript :
* ```js
* exports = commandModule({ })
*
* //or
* exports.default = commandModule({ })
* ```
@@ -35,100 +37,34 @@ export type ModuleResult<T> = Promise<ImportPayload<T>>;
export async function importModule<T>(absPath: string) {
let fileModule = await import(absPath);
let commandModule = fileModule.default;
let commandModule: Module = fileModule.default;
assert(commandModule , `Found no export @ ${absPath}. Forgot to ignore with "!"? (!${basename(absPath)})?`);
if ('default' in commandModule ) {
commandModule = commandModule.default;
assert(commandModule , `No default export @ ${absPath}`);
if ('default' in commandModule) {
commandModule = commandModule.default as Module;
}
return { module: commandModule } as T;
const p = path.parse(absPath)
commandModule.name ??= p.name; commandModule.description ??= "...";
commandModule.meta = {
id: Id.create(commandModule.name, commandModule.type),
absPath,
};
return { module: commandModule as T };
}
export async function defaultModuleLoader<T extends Module>(absPath: string): ModuleResult<T> {
let { module } = await importModule<{ module: T }>(absPath);
assert(module, `Found an undefined module: ${absPath}`);
return { module, absPath };
}
export const fmtFileName = (fileName: string) => parse(fileName).name;
/**
* a directory string is converted into a stream of modules.
* starts the stream of modules that sern needs to process on init
* @returns {Observable<{ mod: Module; absPath: string; }[]>} data from command files
* @param commandDir
*/
export function buildModuleStream<T extends Module>(
input: ObservableInput<string>,
): Observable<ImportPayload<T>> {
return from(input)
.pipe(mergeMap(defaultModuleLoader<T>));
}
export const getFullPathTree = (dir: string) => readPaths(resolve(dir));
export const filename = (path: string) => fmtFileName(basename(path));
const isSkippable = (filename: string) => {
//empty string is for non extension files (directories)
const validExtensions = ['.js', '.cjs', '.mts', '.mjs', '.cts', '.ts', ''];
return filename[0] === '!' || !validExtensions.includes(extname(filename));
};
async function deriveFileInfo(dir: string, file: string) {
const fullPath = join(dir, file);
return { fullPath,
fileStats: await stat(fullPath),
base: basename(file) };
}
async function* readPaths(dir: string): AsyncGenerator<string> {
try {
const files = await readdir(dir);
for (const file of files) {
const { fullPath, fileStats, base } = await deriveFileInfo(dir, file);
if (fileStats.isDirectory()) {
//Todo: refactor so that i dont repeat myself for files (line 71)
if (!isSkippable(base)) {
yield* readPaths(fullPath);
}
} else {
if (!isSkippable(base)) {
yield 'file:///' + fullPath;
}
export async function* readRecursive(dir: string): AsyncGenerator<string> {
const files = await readdir(dir, { withFileTypes: true });
for (const file of files) {
const fullPath = path.posix.join(dir, file.name);
if (file.isDirectory()) {
if (!file.name.startsWith('!')) {
yield* readRecursive(fullPath);
}
} else if (!file.name.startsWith('!')) {
yield "file:///"+path.resolve(fullPath);
}
} catch (err) {
throw err;
}
}
const requir = createRequire(import.meta.url);
export function loadConfig(wrapper: Wrapper | 'file', log: Logging | undefined): Wrapper {
if (wrapper !== 'file') {
return wrapper;
}
log?.info({ message: 'Experimental loading of sern.config.json'});
const config = requir(resolve('sern.config.json'));
const makePath = (dir: PropertyKey) =>
config.language === 'typescript'
? join('dist', config.paths[dir]!)
: join(config.paths[dir]!);
log?.info({ message: 'Loading config: ' + JSON.stringify(config, null, 4) });
const commandsPath = makePath('commands');
log?.info({ message: `Commands path is set to ${commandsPath}` });
let eventsPath: string | undefined;
if (config.paths.events) {
eventsPath = makePath('events');
log?.info({ message: `Events path is set to ${eventsPath} `});
}
return { defaultPrefix: config.defaultPrefix,
commands: commandsPath,
events: eventsPath };
}