feat(apps): apps-engine split, copy content to package/apps #40184

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open

d-gubert wants to merge 12 commits into feat/apps-engine-split--pr1-engine-version from feat/apps-engine-split--pr2a-copy-to-apps

docs/apps-engine-migration.md

Original file line number	Diff line number	Diff line change
Expand Up		@@ -24,3 +24,4 @@ To make this migration easier to understand and review, we're using a stacked PR

		- [40395](https://github.com/RocketChat/Rocket.Chat/pull/40395) The feature branch itself. It will accumulate the changes of the whole stack.
		- [40183](https://github.com/RocketChat/Rocket.Chat/pull/40183) Replaces `AppPackageParser.getEngineVersion()` - which resolved the version by traversing the filesystem relative to `__dirname` - with a direct import of `ENGINE_VERSION`. This will support the migration of the `AppPackageParser` class itself.
		- [40184](https://github.com/RocketChat/Rocket.Chat/pull/40184) Copies all relevant source files from `packages/apps-engine/src/server`, `packages/apps-engine/src/client`, `packages/apps-engine/deno-runtime`, `packages/apps-engine/tests` and `packages/apps-engine/scripts` into their corresponding path at `packages/apps`.

eslint.config.mjs

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -289,7 +289,7 @@ export default [
  
    		},

    	},

    	{

    		files: ['packages/apps-engine/**/*'],

    		files: ['packages/apps-engine/**/*', 'packages/apps/**/*'],

    		rules: {

    			'@typescript-eslint/no-empty-object-type': 'off',

    			'@typescript-eslint/no-unnecessary-type-assertion': 'off', // this rule does not deal well with assertions that remove `undefined` from the type

    @@ -338,14 +338,14 @@ export default [
  
    		},

    	},

    	{

    		files: ['packages/apps-engine/tests/**/*'],

    		files: ['packages/apps-engine/tests/**/*', 'packages/apps/tests/**/*'],

    		rules: {

    			'@typescript-eslint/no-non-null-assertion': 'off',

    			'testing-library/no-await-sync-queries': 'off',

    		},

    	},

    	{

    		ignores: ['packages/apps-engine/@(client|definition|docs|server|lib|deno-runtime|.deno|.deno-cache)'],

    		ignores: ['packages/@(apps|apps-engine)/@(client|definition|docs|server|lib|deno-runtime|.deno|.deno-cache)'],

    	},

    	{

    		files: ['packages/core-typings/**/*'],

packages/apps/.gitignore

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		.deno-cache/
		/tests/test-data/dbs

packages/apps/deno-runtime/.gitignore

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		.deno/

packages/apps/deno-runtime/AppObjectRegistry.ts

-Original file line number
+Diff line change
@@ -0,0 +1,25 @@
+    export type Maybe<T> = T | null | undefined;
+    export const AppObjectRegistry = new class {
+    	registry: Record<string, unknown> = {};
+    	public get<T>(key: string): Maybe<T> {
+    		return this.registry[key] as Maybe<T>;
+    	}
+    	public set(key: string, value: unknown): void {
+    		this.registry[key] = value;
+    	}
+    	public has(key: string): boolean {
+    		return key in this.registry;
+    	}
+    	public delete(key: string): void {
+    		delete this.registry[key];
+    	}
+    	public clear(): void {
+    		this.registry = {};
+    	}
+    }();

packages/apps/deno-runtime/acorn-walk.d.ts

-Original file line number
+Diff line change
@@ -0,0 +1,175 @@
+    import type acorn from './acorn.d.ts';
+    export type FullWalkerCallback<TState> = (
+    	node: acorn.AnyNode,
+    	state: TState,
+    	type: string,
+    ) => void;
+    export type FullAncestorWalkerCallback<TState> = (
+    	node: acorn.AnyNode,
+    	state: TState,
+    	ancestors: acorn.AnyNode[],
+    	type: string,
+    ) => void;
+    type AggregateType = {
+    	Expression: acorn.Expression;
+    	Statement: acorn.Statement;
+    	Pattern: acorn.Pattern;
+    	ForInit: acorn.VariableDeclaration | acorn.Expression;
+    };
+    export type SimpleVisitors<TState> =
+    	& {
+    		[type in acorn.AnyNode['type']]?: (node: Extract<acorn.AnyNode, { type: type }>, state: TState) => void;
+    	}
+    	& {
+    		[type in keyof AggregateType]?: (node: AggregateType[type], state: TState) => void;
+    	};
+    export type AncestorVisitors<TState> =
+    	& {
+    		[type in acorn.AnyNode['type']]?: (node: Extract<acorn.AnyNode, { type: type }>, state: TState, ancestors: acorn.Node[]) => void;
+    	}
+    	& {
+    		[type in keyof AggregateType]?: (node: AggregateType[type], state: TState, ancestors: acorn.Node[]) => void;
+    	};
+    export type WalkerCallback<TState> = (node: acorn.Node, state: TState) => void;
+    export type RecursiveVisitors<TState> =
+    	& {
+    		[type in acorn.AnyNode['type']]?: (node: Extract<acorn.AnyNode, { type: type }>, state: TState, callback: WalkerCallback<TState>) => void;
+    	}
+    	& {
+    		[type in keyof AggregateType]?: (node: AggregateType[type], state: TState, callback: WalkerCallback<TState>) => void;
+    	};
+    export type FindPredicate = (type: string, node: acorn.Node) => boolean;
+    export interface Found<TState> {
+    	node: acorn.Node;
+    	state: TState;
+    }
+    /**
+     * does a 'simple' walk over a tree
+     * @param node the AST node to walk
+     * @param visitors an object with properties whose names correspond to node types in the {@link https://github.com/estree/estree | ESTree spec}. The properties should contain functions that will be called with the node object and, if applicable the state at that point.
+     * @param base a walker algorithm
+     * @param state a start state. The default walker will simply visit all statements and expressions and not produce a meaningful state. (An example of a use of state is to track scope at each point in the tree.)
+     */
+    export function simple<TState>(
+    	node: acorn.Node,
+    	visitors: SimpleVisitors<TState>,
+    	base?: RecursiveVisitors<TState>,
+    	state?: TState,
+    ): void;
+    /**
+     * does a 'simple' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter.
+     * @param node
+     * @param visitors
+     * @param base
+     * @param state
+     */
+    export function ancestor<TState>(
+    	node: acorn.Node,
+    	visitors: AncestorVisitors<TState>,
+    	base?: RecursiveVisitors<TState>,
+    	state?: TState,
+    ): void;
+    /**
+     * does a 'recursive' walk, where the walker functions are responsible for continuing the walk on the child nodes of their target node.
+     * @param node
+     * @param state the start state
+     * @param functions contain an object that maps node types to walker functions
+     * @param base provides the fallback walker functions for node types that aren't handled in the {@link functions} object. If not given, the default walkers will be used.
+     */
+    export function recursive<TState>(
+    	node: acorn.Node,
+    	state: TState,
+    	functions: RecursiveVisitors<TState>,
+    	base?: RecursiveVisitors<TState>,
+    ): void;
+    /**
+     * does a 'full' walk over a tree, calling the {@link callback} with the arguments (node, state, type) for each node
+     * @param node
+     * @param callback
+     * @param base
+     * @param state
+     */
+    export function full<TState>(
+    	node: acorn.Node,
+    	callback: FullWalkerCallback<TState>,
+    	base?: RecursiveVisitors<TState>,
+    	state?: TState,
+    ): void;
+    /**
+     * does a 'full' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter.
+     * @param node
+     * @param callback
+     * @param base
+     * @param state
+     */
+    export function fullAncestor<TState>(
+    	node: acorn.AnyNode,
+    	callback: FullAncestorWalkerCallback<TState>,
+    	base?: RecursiveVisitors<TState>,
+    	state?: TState,
+    ): void;
+    /**
+     * builds a new walker object by using the walker functions in {@link functions} and filling in the missing ones by taking defaults from {@link base}.
+     * @param functions
+     * @param base
+     */
+    export function make<TState>(
+    	functions: RecursiveVisitors<TState>,
+    	base?: RecursiveVisitors<TState>,
+    ): RecursiveVisitors<TState>;
+    /**
+     * tries to locate a node in a tree at the given start and/or end offsets, which satisfies the predicate test. {@link start} and {@link end} can be either `null` (as wildcard) or a `number`. {@link test} may be a string (indicating a node type) or a function that takes (nodeType, node) arguments and returns a boolean indicating whether this node is interesting. {@link base} and {@link state} are optional, and can be used to specify a custom walker. Nodes are tested from inner to outer, so if two nodes match the boundaries, the inner one will be preferred.
+     * @param node
+     * @param start
+     * @param end
+     * @param type
+     * @param base
+     * @param state
+     */
+    export function findNodeAt<TState>(
+    	node: acorn.AnyNode,
+    	start: number | undefined,
+    	end?: number | undefined,
+    	type?: FindPredicate | string,
+    	base?: RecursiveVisitors<TState>,
+    	state?: TState,
+    ): Found<TState> | undefined;
+    /**
+     * like {@link findNodeAt}, but will match any node that exists 'around' (spanning) the given position.
+     * @param node
+     * @param start
+     * @param type
+     * @param base
+     * @param state
+     */
+    export function findNodeAround<TState>(
+    	node: acorn.AnyNode,
+    	start: number | undefined,
+    	type?: FindPredicate | string,
+    	base?: RecursiveVisitors<TState>,
+    	state?: TState,
+    ): Found<TState> | undefined;
+    /**
+     * similar to {@link findNodeAround}, but will match all nodes after the given position (testing outer nodes before inner nodes).
+     */
+    export const findNodeAfter: typeof findNodeAround;
+    export const base: RecursiveVisitors<unknown>;

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

feat(apps): apps-engine split, copy content to package/apps #40184

Uh oh!

Diff view

Diff view

Uh oh!

There are no files selected for viewing

Uh oh!

Uh oh!

feat(apps): apps-engine split, copy content to package/apps #40184

Are you sure you want to change the base?

Uh oh!

feat(apps): apps-engine split, copy content to package/apps #40184

Uh oh!

Diff view

Diff view

Uh oh!

There are no files selected for viewing

Uh oh!

Uh oh!