Merge branch 'edge'

Related to freshgiammi-lab/connect-typeorm#8

Closes #128

docs/subreddit-configuration/in-depth/author/authorFilter.json5

@@ -40,7 +40,7 @@
                   // for this to pass the Author of the Submission must not have the flair "Supreme Memer" and have the name "user1" or "user2"
                   {
                     "flairText": ["Supreme Memer"],
-                    "names": ["user1","user2"]
+                    "name": ["user1","user2"]
                   },
                   {
                     // for this to pass the Author of the Submission must not have the flair "Decent Memer"

docs/subreddit-configuration/in-depth/author/authorFilter.yaml

@@ -30,7 +30,7 @@ runs:
                 # for this to pass the Author of the Submission must not have the flair "Supreme Memer" and have the name "user1" or "user2"
                 - flairText:
                     - Supreme Memer
-                  names:
+                  name:
                     - user1
                     - user2
                   # for this to pass the Author of the Submission must not have the flair "Decent Memer"

src/Action/SubmissionAction/FlairAction.ts

@@ -43,11 +43,7 @@ export class FlairAction extends Action {
         if (item instanceof Submission) {
             if(!this.dryRun) {
                 if (this.flair_template_id) {
-                    // typings are wrong for this function, flair_template_id should be accepted
-                    // assignFlair uses /api/flair (mod endpoint)
-                    // selectFlair uses /api/selectflair (self endpoint for user to choose their own flair for submission)
-                    // @ts-ignore
-                    await item.assignFlair({flair_template_id: this.flair_template_id}).then(() => {});
+                    await item.selectFlair({flair_template_id: this.flair_template_id}).then(() => {});
                     item.link_flair_template_id = this.flair_template_id;
                 } else {
                     await item.assignFlair({text: renderedText, cssClass: renderedCss}).then(() => {});

src/Common/interfaces.ts

@@ -748,10 +748,6 @@ export interface RegExResult {
     named: NamedGroup
 }
 
-export interface RegExResultWithTest extends RegExResult {
-    test: RegExp
-}
-
 export type StrongCache = {
     authorTTL: number | boolean,
     userNotesTTL: number | boolean,

src/Rule/RegexRule.ts

@@ -7,7 +7,6 @@ import {
     PASS, triggeredIndicator, windowConfigToWindowCriteria
 } from "../util";
 import {
-    RegExResultWithTest,
     RuleResult,
 } from "../Common/interfaces";
 import dayjs from 'dayjs';
@@ -15,11 +14,10 @@ import {SimpleError} from "../Utils/Errors";
 import {JoinOperands} from "../Common/Infrastructure/Atomic";
 import {ActivityWindowConfig} from "../Common/Infrastructure/ActivityWindow";
 import {
-    comparisonTextOp, GenericComparison,
+    comparisonTextOp,
     parseGenericValueComparison,
     parseGenericValueOrPercentComparison
 } from "../Common/Infrastructure/Comparisons";
-import {SnoowrapActivity} from "../Common/Infrastructure/Reddit";
 
 export interface RegexCriteria {
     /**
@@ -29,23 +27,13 @@ export interface RegexCriteria {
      * */
     name?: string
     /**
-     * A valid Regular Expression, or list of expressions, to test content against
+     * A valid Regular Expression to test content against
      *
      * If no flags are specified then the **global** flag is used by default
      *
      * @examples ["/reddit|FoxxMD/ig"]
      * */
-    regex: string | string[],
-
-    /**
-     * Determines if ALL regexes listed are run or if regexes are only run until one is matched.
-     *
-     * * `true` => all regexes are always run
-     * * `false` => regexes are run until one matches
-     *
-     * @default false
-     * */
-    exhaustive?: boolean
+    regex: string,
 
     /**
      * Which content from an Activity to test the regex against
@@ -169,7 +157,6 @@ export class RegexRule extends Rule {
             const {
                 name = (index + 1),
                 regex,
-                exhaustive = false,
                 testOn: testOnVals = ['title', 'body'],
                 lookAt = 'all',
                 matchThreshold = '> 0',
@@ -187,7 +174,13 @@ export class RegexRule extends Rule {
                 return acc.concat(curr);
             }, []);
 
-            const regexTests: RegExp[] = await this.convertToRegexArray(name, regex);
+            // check regex
+            const regexContent = await this.resources.getContent(regex);
+            const reg = parseStringToRegex(regexContent, 'g');
+            if(reg === undefined) {
+                throw new SimpleError(`Value given for regex on Criteria ${name} was not valid: ${regex}`);
+            }
+            // ok cool its a valid regex
 
             const matchComparison = parseGenericValueComparison(matchThreshold);
             const activityMatchComparison = activityMatchThreshold === null ? undefined : parseGenericValueOrPercentComparison(activityMatchThreshold);
@@ -205,13 +198,12 @@ export class RegexRule extends Rule {
 
             // first lets see if the activity we are checking satisfies thresholds
             // since we may be able to avoid api calls to get history
-            let actMatches = getMatchesFromActivity(item, testOn, regexTests, exhaustive);
-            const actMatchSummary = regexResultsSummary(actMatches);
-            matches = matches.concat(actMatchSummary.matches).slice(0, 100);
-            matchCount += actMatchSummary.matches.length;
+            let actMatches = this.getMatchesFromActivity(item, testOn, reg);
+            matches = matches.concat(actMatches).slice(0, 100);
+            matchCount += actMatches.length;
 
             activitiesTested++;
-            const singleMatched = comparisonTextOp(actMatchSummary.matches.length, matchComparison.operator, matchComparison.value);
+            const singleMatched = comparisonTextOp(actMatches.length, matchComparison.operator, matchComparison.value);
             if (singleMatched) {
                 activitiesMatchedCount++;
             }
@@ -241,7 +233,7 @@ export class RegexRule extends Rule {
                 }
 
                 history = await this.resources.getAuthorActivities(item.author, strongWindow);
-                // remove current activity if it exists in history so we don't count it twice
+                // remove current activity it exists in history so we don't count it twice
                 history = history.filter(x => x.id !== item.id);
                 const historyLength = history.length;
 
@@ -260,12 +252,10 @@ export class RegexRule extends Rule {
 
                 for (const h of history) {
                     activitiesTested++;
-                    const aMatches = getMatchesFromActivity(h, testOn, regexTests, exhaustive);
-                    actMatches = actMatches.concat(aMatches);
-                    const actHistoryMatchSummary = regexResultsSummary(aMatches);
-                    matches = matches.concat(actHistoryMatchSummary.matches).slice(0, 100);
-                    matchCount += actHistoryMatchSummary.matches.length;
-                    const matched = comparisonTextOp(actHistoryMatchSummary.matches.length, matchComparison.operator, matchComparison.value);
+                    const aMatches = this.getMatchesFromActivity(h, testOn, reg);
+                    matches = matches.concat(aMatches).slice(0, 100);
+                    matchCount += aMatches.length;
+                    const matched = comparisonTextOp(aMatches.length, matchComparison.operator, matchComparison.value);
                     if (matched) {
                         activitiesMatchedCount++;
                     }
@@ -292,19 +282,10 @@ export class RegexRule extends Rule {
                 humanWindow = '1 Item';
             }
 
-            // to provide at least one useful regex for this criteria
-            // use the first regex found by default
-            let relevantRegex: string = regexTests[0].toString();
-            // but if more than one regex was listed AND we did have matches
-            // then use the first regex that actually got a match
-            if(regexTests.length > 0 && actMatches.length > 0) {
-                relevantRegex = actMatches[0].test.toString();
-            }
-
             const critResults = {
                 criteria: {
                     name,
-                    regex: relevantRegex,
+                    regex: regex !== regexContent ? `${regex} from ${regexContent}` : regex,
                     testOn,
                     matchThreshold,
                     activityMatchThreshold,
@@ -371,115 +352,42 @@ export class RegexRule extends Rule {
         return Promise.resolve([criteriaMet, this.getResult(criteriaMet, {result, data: {results: criteriaResults, matchSample }})]);
     }
 
-    protected async convertToRegexArray(name: string | number, value: string | string[]): Promise<RegExp[]> {
-        const regexTests: RegExp[] = [];
-        const regexStringVals = typeof value === 'string' ? [value] : value;
-        for(const r of regexStringVals) {
-            // check regex
-            const regexContent = await this.resources.getContent(r);
-            const reg = parseStringToRegex(regexContent, 'ig');
-            if (reg === undefined) {
-                throw new SimpleError(`Value given for regex on Criteria ${name} was not valid: ${value}`);
-            }
-            // ok cool its a valid regex
-            regexTests.push(reg);
-        }
-        return regexTests;
-    }
-}
-
-export const getMatchResultsFromContent = (contents: string[], reg: RegExp): RegExResultWithTest[] => {
-    let m: RegExResultWithTest[] = [];
-    for (const c of contents) {
-        const results = parseRegex(reg, c);
-        if(results !== undefined) {
-            for(const r of results) {
-                m.push({...r, test: reg});
-            }
-        }
-    }
-    return m;
-}
-
-export const regexResultsSummary = (results: RegExResultWithTest[]) => {
-    const matchResults: ActivityMatchResults = {
-        matches: [],
-        matchesByTest: {},
-        groups: {}
-    }
-
-    for (const r of results) {
-        if (matchResults.matchesByTest[r.test.toString()] === undefined) {
-            matchResults.matchesByTest[r.test.toString()] = [];
-        }
-        matchResults.matchesByTest[r.test.toString()].push(r.match);
-        matchResults.matches.push(r.match);
-        if (r.named !== undefined) {
-            Object.entries(r.named).forEach(([key, val]) => {
-                if (matchResults.groups[key] === undefined) {
-                    matchResults.groups[key] = [];
+    protected getMatchesFromActivity(a: (Submission | Comment), testOn: string[], reg: RegExp): string[] {
+        let m: string[] = [];
+        // determine what content we are testing
+        let contents: string[] = [];
+        if (asSubmission(a)) {
+            for (const l of testOn) {
+                switch (l) {
+                    case 'title':
+                        contents.push(a.title);
+                        break;
+                    case 'body':
+                        if (a.is_self) {
+                            contents.push(a.selftext);
+                        }
+                        break;
+                    case 'url':
+                        if (isExternalUrlSubmission(a)) {
+                            contents.push(a.url);
+                        }
+                        break;
                 }
-                matchResults.groups[key].push(val);
-            });
+            }
+        } else {
+            contents.push(a.body)
         }
-    }
-    return matchResults;
-}
 
-export const getMatchesFromActivity = (a: (Submission | Comment), testOn: string[], regexes: RegExp[], exhaustive: boolean): RegExResultWithTest[] => {
-    // determine what content we are testing
-    let contents: string[] = getMatchableContent(a, testOn);
-    let results: RegExResultWithTest[] = [];
-
-    for (const reg of regexes) {
-        const res = getMatchResultsFromContent(contents, reg);
-        if(res.length > 0) {
-            results = results.concat(res);
-            // only continue testing if the user wants to exhaustively check all regexes (to get more matches?)
-            if(!exhaustive) {
-                return results;
+        for (const c of contents) {
+            const results = parseRegex(reg, c);
+            if(results !== undefined) {
+                for(const r of results) {
+                    m.push(r.match);
+                }
             }
         }
+        return m;
     }
-    return results;
-}
-
-const getMatchableContent = (a: SnoowrapActivity, testOn: string[]) => {
-    let contents: string[] = [];
-    if (asSubmission(a)) {
-        for (const l of testOn) {
-            switch (l) {
-                case 'title':
-                    contents.push(a.title);
-                    break;
-                case 'body':
-                    if (a.is_self) {
-                        contents.push(a.selftext);
-                    }
-                    break;
-                case 'url':
-                    if (isExternalUrlSubmission(a)) {
-                        contents.push(a.url);
-                    }
-                    break;
-            }
-        }
-    } else {
-        contents.push(a.body)
-    }
-    return contents;
-}
-
-interface RegexMatchComparisonOptions {
-    matchComparison: GenericComparison
-    activityMatchComparison?: GenericComparison
-    totalMatchComparison?: GenericComparison
-}
-
-interface ActivityMatchResults {
-    matches: string[]
-    matchesByTest: Record<string, string[]>
-    groups: Record<string, string[]>
 }
 
 interface RegexConfig {

src/Web/Client/StorageProvider.ts

@@ -12,6 +12,7 @@ import {Logger} from "winston";
 import {WebSetting} from "../../Common/WebEntities/WebSetting";
 import {ErrorWithCause} from "pony-cause";
 import {createCacheManager} from "../../Common/Cache";
+import {MysqlDriver} from "typeorm/driver/mysql/MysqlDriver";
 
 export interface CacheManagerStoreOptions {
     prefix?: string
@@ -103,7 +104,12 @@ export class DatabaseStorageProvider extends StorageProvider {
     }
 
     createSessionStore(options?: TypeormStoreOptions): Store {
-        return new TypeormStore(options).connect(this.clientSessionRepo)
+        // https://github.com/freshgiammi-lab/connect-typeorm#implement-the-session-entity
+        // https://github.com/freshgiammi-lab/connect-typeorm/issues/8
+        // usage of LIMIT in subquery is not supported by mariadb/mysql
+        // limitSubquery: false -- turns off LIMIT usage
+        const realOptions = this.database.driver instanceof MysqlDriver ? {...options, limitSubquery: false} : options;
+        return new TypeormStore(realOptions).connect(this.clientSessionRepo)
     }
 
     async getSessionSecret(): Promise<string | undefined> {