@mcpher/gas-fakes 2.3.11 → 2.3.14

package/README.md

@@ -35,7 +35,7 @@ Now you can run apps script code directly from your console - for example
 gas-fakes  -s "const files=DriveApp.getRootFolder().searchFiles('title contains \"Untitled\"');while (files.hasNext()) {console.log(files.next().getName())};" 
 ```
 
-For details see [gas fakes cli](gas-fakes-cli.md)
+For details see [gas fakes cli](notes/gas-fakes-cli.md)
 
 ### Configuration
 
@@ -168,7 +168,7 @@ There are a couple of syntactical differences between Node and Apps Script. Not
 // this required on Node but not on Apps Script
 if (ScriptApp.isFake) testFakes()
 ````
-For inspiration on pushing modified files to the IDE, see the togas.sh bash script I use for the test suite. There's also a complete push pull workflow available - see - [push test pull](pull-test-push.md)
+For inspiration on pushing modified files to the IDE, see the togas.sh bash script I use for the test suite. There's also a complete push pull workflow available - see - [push test pull](notes/pull-test-push.md)
 
 
 ## Help
@@ -188,11 +188,11 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [readme](README.md)
 - [Natural Language Automation with Gemini Skills & MCP Server](gemini-skills-mcp.md) - new skills-based agent approach.
 - [gf_agent documentation](../gf_agent/README.md) - instructions for the Gemini CLI automation agent and MCP server.
-- [gas fakes cli](gas-fakes-cli.md)
+- [gas fakes cli](notes/gas-fakes-cli.md)
 - [github actions using adc](https://github.com/brucemcpherson/gas-fakes-actions-adc)
 - [github actions using dwd and wif](https://github.com/brucemcpherson/gas-fakes-actions-dwd)
-- [ksuite as a back end](ksuite_poc.md)
-- [msgraph as a back end](msgraph.md)
+- [ksuite as a back end](notes/ksuite_poc.md)
+- [msgraph as a back end](notes/msgraph.md)
 - [resurrecting scriptDb repo](https://github.com/brucemcpherson/scriptdb-redux)
 - [Resurrecting ScriptDb – nosql database for Apps Script](https://ramblings.mcpher.com/resurrecting-scriptdb-nosql-database-for-apps-script/)
 - [gas-fakes in serverless containers](https://docs.google.com/presentation/d/1JlXF9T--DD4ERHopyP3WyAMhjRCxxHblgCP5ynxaJ3k/edit?usp=sharing)
@@ -203,7 +203,7 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [running gas-fakes on Amazon AWS lambda](https://github.com/brucemcpherson/gas-fakes-containers)
 - [running gas-fakes on Azure ACA](https://github.com/brucemcpherson/gas-fakes-containers)
 - [running gas-fakes on Github actions](https://github.com/brucemcpherson/gas-fakes-containers)
-- [jdbc notes](jdbc-notes.md)
+- [jdbc notes](notes/jdbc-notes.md)
 - [Yes – you can run native apps script code on Azure ACA as well!](https://ramblings.mcpher.com/yes-you-can-run-native-apps-script-code-on-azure-aca-as-well/)
 - [Yes – you can run native apps script code on AWS Lambda!](https://ramblings.mcpher.com/apps-script-on-aws-lambda/)
 - [initial idea and thoughts](https://ramblings.mcpher.com/a-proof-of-concept-implementation-of-apps-script-environment-on-node/)
@@ -213,16 +213,16 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [Turning async into synch on Node using workers](https://ramblings.mcpher.com/turning-async-into-synch-on-node-using-workers/)
 - [All about Apps Script Enums and how to fake them](https://ramblings.mcpher.com/all-about-apps-script-enums-and-how-to-fake-them/)
 - [colaborators](collaborators.md) - additional information for collaborators
-- [oddities](oddities.md) - a collection of oddities uncovered during this project
-- [named colors](named-colors.md)
-- [sandbox](sandbox.md)
-- [senstive scopes](workspace_scopes.md)
-- [using apps script libraries with gas-fakes](libraries.md)
+- [oddities](notes/oddities.md) - a collection of oddities uncovered during this project
+- [named colors](notes/named-colors.md)
+- [sandbox](notes/sandbox.md)
+- [senstive scopes](notes/workspace_scopes.md)
+- [using apps script libraries with gas-fakes](notes/libraries.md)
 - [how libhandler works](libhandler.md)
 - [article:using apps script libraries with gas-fakes](https://ramblings.mcpher.com/how-to-use-apps-script-libraries-directly-from-node/)
-- [named range identity](named-range-identity.md)
-- [Workspace scopes with local authentication](workspace_scopes.md)
-- [push test pull](pull-test-push.md)
+- [named range identity](notes/named-range-identity.md)
+- [Workspace scopes with local authentication](notes/workspace_scopes.md)
+- [push test pull](notes/pull-test-push.md)
 - [sharing cache and properties between gas-fakes and live apps script](https://ramblings.mcpher.com/sharing-cache-and-properties-between-gas-fakes-and-live-apps-script/)
 - [gas-fakes-cli now has built in mcp server and gemini extension](https://ramblings.mcpher.com/gas-fakes-cli-now-has-built-in-mcp-server-and-gemini-extension/)
 - [gas-fakes CLI: Run apps script code directly from your terminal](https://ramblings.mcpher.com/gas-fakes-cli-run-apps-script-code-directly-from-your-terminal/)

package/gas-fakes.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+process.env.GF_CLI_INTERACTIVE = "true";
 import { main } from "./src/cli/app.js";
 
 main().catch((error) => {

package/gf_agent/scripts/builder.js

@@ -1,62 +1,118 @@
 import fs from 'fs/promises';
 import path from 'path';
+import { fileURLToPath } from 'url';
 
-const PROGRESS_DIR = './progress';
-const SKILLS_DIR = './gf_agent/skills';
-const INDEX_FILE = './gf_agent/index.md';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// The script is at gf_agent/scripts/builder.js, so the root is one level up
+const GF_AGENT_DIR = path.resolve(__dirname, '..');
+
+// Standardize paths relative to the gf_agent directory
+const SKILLS_DIR = path.join(GF_AGENT_DIR, 'skills');
+const INDEX_FILE = path.join(GF_AGENT_DIR, 'index.md');
+const TEMPLATE_FILE = path.join(__dirname, 'SKILL.template.md');
+const KNOWLEDGE_DIR = path.join(GF_AGENT_DIR, 'knowledge');
+const SKILL_OUTPUT = path.join(GF_AGENT_DIR, 'SKILL.md');
+
+// Use CWD for progress dir to allow user to provide it in a sparse clone/standalone env
+const PROGRESS_DIR = path.resolve(process.cwd(), 'progress');
 
 async function build() {
-  await fs.mkdir(SKILLS_DIR, { recursive: true });
+  // Cleanup potential junk from previous runs where paths were relative to CWD 
+  // (e.g. if run from within gf_agent/scripts, it might have created gf_agent/scripts/gf_agent)
+  try {
+    const junkDir = path.join(__dirname, 'gf_agent');
+    await fs.rm(junkDir, { recursive: true, force: true });
+  } catch (err) {
+    // Ignore
+  }
 
-  const files = await fs.readdir(PROGRESS_DIR);
-  const mdFiles = files.filter(f => f.endsWith('.md') || f.endsWith('.MD'));
+  await fs.mkdir(SKILLS_DIR, { recursive: true });
 
   let masterIndex = '# gf_agent Skills Index\n\nThis index lists all Google Apps Script services and classes supported by `gf_agent` via `gas-fakes`.\n\n';
 
-  for (const file of mdFiles) {
-    const content = await fs.readFile(path.join(PROGRESS_DIR, file), 'utf-8');
-    const serviceName = file.replace(/\.md$/i, '');
-    
-    // Extract classes
-    const classMatches = content.matchAll(/## Class: \[(.*?)\]/g);
-    const classes = [];
-    
-    for (const match of classMatches) {
-      const className = match[1];
-      // Find the table for this class
-      const classSection = content.slice(match.index);
-      const tableEnd = classSection.indexOf('## Class:') > 0 ? classSection.indexOf('## Class:', 10) : classSection.length;
-      const tableContent = classSection.slice(0, tableEnd);
+  try {
+    // Check if progress directory exists before attempting to read
+    await fs.access(PROGRESS_DIR);
+    const files = await fs.readdir(PROGRESS_DIR);
+    const mdFiles = files.filter(f => f.endsWith('.md') || f.endsWith('.MD'));
+
+    for (const file of mdFiles) {
+      const content = await fs.readFile(path.join(PROGRESS_DIR, file), 'utf-8');
+      const serviceName = file.replace(/\.md$/i, '');
       
-      // Extract completed methods
-      const methodMatches = tableContent.matchAll(/\| \[(.*?)\]\(.*?\) \| .*? \| .*? \| .*? \| (completed) \|/g);
-      const methods = Array.from(methodMatches).map(m => m[1]);
+      // Extract classes
+      const classMatches = content.matchAll(/## Class: \[(.*?)\]/g);
+      const classes = [];
       
-      if (methods.length > 0) {
-        classes.push({ name: className, methods });
+      for (const match of classMatches) {
+        const className = match[1];
+        // Find the table for this class
+        const classSection = content.slice(match.index);
+        const tableEnd = classSection.indexOf('## Class:') > 0 ? classSection.indexOf('## Class:', 10) : classSection.length;
+        const tableContent = classSection.slice(0, tableEnd);
+        
+        // Extract completed methods
+        const methodMatches = tableContent.matchAll(/\| \[(.*?)\]\(.*?\) \| .*? \| .*? \| .*? \| (completed) \|/g);
+        const methods = Array.from(methodMatches).map(m => m[1]);
+        
+        if (methods.length > 0) {
+          classes.push({ name: className, methods });
+        }
       }
-    }
 
-    if (classes.length > 0) {
-      const skillFile = `${serviceName.toLowerCase()}.md`;
-      let skillContent = `# Service: ${serviceName}\n\n`;
-      
-      classes.forEach(c => {
-        skillContent += `## Class: ${c.name}\n\n`;
-        skillContent += `Supported Methods:\n`;
-        c.methods.forEach(m => {
-          skillContent += `- \`${m}\`\n`;
+      if (classes.length > 0) {
+        const skillFile = `${serviceName.toLowerCase()}.md`;
+        let skillContent = `# Service: ${serviceName}\n\n`;
+        
+        classes.forEach(c => {
+          skillContent += `## Class: ${c.name}\n\n`;
+          skillContent += `Supported Methods:\n`;
+          c.methods.forEach(m => {
+            skillContent += `- \`${m}\`\n`;
+          });
+          skillContent += '\n';
         });
-        skillContent += '\n';
-      });
 
-      await fs.writeFile(path.join(SKILLS_DIR, skillFile), skillContent);
-      masterIndex += `- [${serviceName}](skills/${skillFile})\n`;
+        await fs.writeFile(path.join(SKILLS_DIR, skillFile), skillContent);
+        masterIndex += `- [${serviceName}](skills/${skillFile})\n`;
+      }
+    }
+
+    await fs.writeFile(INDEX_FILE, masterIndex);
+    console.log(`Skills and Index generated from ${PROGRESS_DIR}`);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      console.log(`Skipping skills index generation: ${PROGRESS_DIR} not found.`);
+    } else {
+      console.log(`Skipping skills index generation: ${err.message}`);
+    }
+    console.log(`(This is expected in a sparse clone environment).`);
+  }
+  
+  // Aggregate knowledge files into SKILL.md
+  let skillMarkdown = await fs.readFile(TEMPLATE_FILE, 'utf-8');
+  
+  try {
+    const knowledgeFiles = await fs.readdir(KNOWLEDGE_DIR);
+    // Sort files to ensure deterministic aggregation (e.g., 01-drive.md, 02-syntax.md)
+    knowledgeFiles.sort();
+    
+    for (const kFile of knowledgeFiles) {
+      if (kFile.endsWith('.md')) {
+        const kContent = await fs.readFile(path.join(KNOWLEDGE_DIR, kFile), 'utf-8');
+        skillMarkdown += `\n${kContent}\n`;
+      }
     }
+  } catch (err) {
+    console.log(`No knowledge directory found at ${KNOWLEDGE_DIR} or error reading it:`, err.message);
   }
 
-  await fs.writeFile(INDEX_FILE, masterIndex);
-  console.log('Build complete! Skills and Index generated.');
+  await fs.writeFile(SKILL_OUTPUT, skillMarkdown);
+
+  console.log(`Build complete! Skills, Index, and monolithic SKILL.md generated at ${SKILL_OUTPUT}`);
 }
 
 build().catch(console.error);
+

package/package.json

@@ -40,7 +40,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.3.11",
+  "version": "2.3.14",
   "license": "MIT",
   "main": "main.js",
   "description": "An implementation of the Google Workspace Apps Script runtime: Run native App Script Code on Node and Cloud Run",

package/src/cli/lib-manager.js

@@ -1,6 +1,6 @@
 import fs from "fs";
 import { parse } from "acorn";
-import { Auth } from "../support/auth.js"; // Relative to gas-fakes-cli directory
+import { Auth, _identities } from "../support/auth.js"; // Relative to gas-fakes-cli directory
 import { checkForGcloudCli, spawnCommand } from "./utils.js";
 
 async function getAccessToken(pattern) {
@@ -8,12 +8,22 @@ async function getAccessToken(pattern) {
     // Authorization pattern 1
     // We use cloud-platform as it provides sufficient access for Drive API fetching
     // while avoiding the 'well-known client ID' block that targets Workspace scopes like drive.readonly.
-    const auth = await Auth.setAuth(
+    const client = await Auth.setAuth(
       ["https://www.googleapis.com/auth/cloud-platform"],
       true
     );
-    auth.cachedCredential = null;
-    return await auth.getAccessToken();
+    if (client.cachedCredential !== undefined) {
+       client.cachedCredential = null;
+    }
+    const tokenResponse = await client.getAccessToken();
+    const token = tokenResponse.token || tokenResponse; 
+
+    // CRITICAL: We MUST clear the global identities map so that this temporary
+    // library-fetching auth does not trick the downstream executor.js and syncit.js 
+    // into thinking the full environment (and the background worker) has been initialized.
+    _identities.clear();
+
+    return token;
   } else {
     // Authorization pattern 2
     await checkForGcloudCli();

package/src/cli/setup.js

@@ -622,11 +622,102 @@ export async function initializeConfiguration(options = {}) {
 
   if (skillResponse.installSkills) {
     console.log("Installing Gemini CLI skills and MCP server...");
+    let manualSkillCmd;
     try {
-      // 1. Install the agent skill
-      const skillCmd = "gemini skills install https://github.com/brucemcpherson/gas-fakes.git --path gf_agent";
-      console.log(`Executing: ${skillCmd}`);
-      execSync(skillCmd, { stdio: "inherit" });
+      // 1. Install or link the agent skill
+      let skillCmd;
+      const gfAgentSubdir = path.resolve(process.cwd(), "gf_agent", "SKILL.md");
+      const gfAgentCurrent = path.resolve(process.cwd(), "SKILL.md");
+
+      if (fs.existsSync(gfAgentSubdir)) {
+        console.log("Detected local gas-fakes repository. Linking local skill for development...");
+        skillCmd = "gemini skills link ./gf_agent --consent";
+        manualSkillCmd = "1. gemini skills link ./gf_agent";
+        execSync(skillCmd, { stdio: ["ignore", "pipe", "ignore"] });
+        console.log("Skill linked successfully.");
+      } else if (fs.existsSync(gfAgentCurrent) && fs.existsSync(path.resolve(process.cwd(), "index.md"))) {
+        console.log("Detected local gf_agent directory. Linking local skill for development...");
+        skillCmd = "gemini skills link . --consent";
+        manualSkillCmd = "1. gemini skills link .";
+        execSync(skillCmd, { stdio: ["ignore", "pipe", "ignore"] });
+        console.log("Skill linked successfully.");
+      } else {
+        // Not a local clone, check if already installed to avoid overwriting
+        let isAlreadyInstalled = false;
+        try {
+          const existingSkills = execSync("gemini skills list", {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+          });
+          if (existingSkills.includes("gf_agent")) {
+            isAlreadyInstalled = true;
+          }
+        } catch (err) {
+          // Ignore errors checking skills list
+        }
+
+        if (isAlreadyInstalled) {
+          console.log("gf_agent skill is already installed. Skipping remote installation.");
+          manualSkillCmd = "1. gemini skills update gf_agent (if needed)";
+        } else {
+          const installChoice = await prompts({
+            type: "select",
+            name: "method",
+            message: "How would you like to install the gf_agent skill?",
+            choices: [
+              {
+                title: "Global (Standard)",
+                value: "global",
+                description: "Recommended for most users. Installs a read-only copy globally.",
+              },
+              {
+                title: "Local Standalone (Contributor)",
+                value: "local",
+                description: "Installs a local sparse-clone for skill development and linking.",
+              },
+            ],
+            initial: 0,
+          });
+
+          if (installChoice.method === "local") {
+            const standaloneDir = "gf_agent_standalone";
+            const fullStandalonePath = path.resolve(process.cwd(), standaloneDir);
+            console.log(`Setting up local standalone skill environment in "./${standaloneDir}"...`);
+
+            try {
+              if (!fs.existsSync(fullStandalonePath)) {
+                fs.mkdirSync(fullStandalonePath, { recursive: true });
+                execSync("git init", { cwd: fullStandalonePath, stdio: "ignore" });
+                execSync("git remote add origin https://github.com/brucemcpherson/gas-fakes.git", {
+                  cwd: fullStandalonePath,
+                  stdio: "ignore",
+                });
+                execSync("git config core.sparseCheckout true", { cwd: fullStandalonePath, stdio: "ignore" });
+
+                const sparsePath = path.join(fullStandalonePath, ".git", "info", "sparse-checkout");
+                fs.writeFileSync(sparsePath, "gf_agent/*\n");
+              }
+
+              execSync("git pull origin main", { cwd: fullStandalonePath, stdio: "ignore" });
+
+              skillCmd = "gemini skills link ./gf_agent --consent";
+              execSync(skillCmd, { cwd: fullStandalonePath, stdio: ["ignore", "pipe", "ignore"] });
+              console.log("Skill linked successfully.");
+
+              manualSkillCmd = `1. cd ${standaloneDir} && gemini skills link ./gf_agent`;
+            } catch (gitErr) {
+              console.error(`Error during local setup: ${gitErr.message}`);
+              throw gitErr;
+            }
+          } else {
+            skillCmd = "gemini skills install https://github.com/brucemcpherson/gas-fakes.git --path gf_agent --consent";
+            manualSkillCmd = "1. gemini skills install https://github.com/brucemcpherson/gas-fakes.git --path gf_agent";
+            console.log(`Installing global skill from remote...`);
+            execSync(skillCmd, { stdio: ["ignore", "pipe", "ignore"] });
+            console.log("Skill installed successfully.");
+          }
+        }
+      }
 
       // 2. Add the MCP server
       const mcpCmd = "gemini mcp add --scope project gas-fakes-mcp gas-fakes mcp";
@@ -635,11 +726,11 @@ export async function initializeConfiguration(options = {}) {
 
       console.log("\x1b[1;32mInstallation complete!\x1b[0m");
       console.log("\nYou can now use natural language to automate tasks:");
-      console.log("   \x1b[1;33m\"Create a spreadsheet of my recent Drive files\"\x1b[0m");
+      console.log("   \x1b[1;33m\“Create a sheet called ‘Todays drive files' and add any files on Drive modified today to it\"\x1b[0m");
     } catch (err) {
       console.error(`\x1b[1;31mError during Gemini installation: ${err.message}\x1b[0m`);
       console.log("You may need to install them manually:");
-      console.log("1. gemini skills install https://github.com/brucemcpherson/gas-fakes.git --path gf_agent");
+      console.log(manualSkillCmd);
       console.log("2. gemini mcp add --scope project gas-fakes-mcp gas-fakes mcp");
     }
   } else {

package/src/services/chartsapp/fakechartsapp.js

@@ -19,7 +19,12 @@ export const newFakeChartsApp = (...args) => {
 export class FakeChartsApp {
   constructor() {
     const enumProps = [
-      "ChartType", //	ChartType	An enumeration of the possible chart types.
+      "ChartType", //   ChartType       An enumeration of the possible chart types.
+      "ChartHiddenDimensionStrategy",
+      "ChartMergeStrategy",
+      "CurveStyle",
+      "PointStyle",
+      "Position"
     ];
 
     // import all known enums as props of chartsapp

package/src/services/driveapp/driveiterators.js

@@ -14,14 +14,33 @@ export const getFilesIterator = ({
   qob,
   parentId = null,
   folderTypes,
-  fileTypes
+  fileTypes,
+  token
 }) => {
 
 
   // parentId can be null to search everywhere
   if (!is.null(parentId)) assert.nonEmptyString(parentId)
-  assert.boolean(folderTypes)
-  assert.boolean(fileTypes)
+  assert.boolean(folderTypes || !!token)
+  assert.boolean(fileTypes || !!token)
+
+  let state = {
+    qob,
+    parentId,
+    folderTypes,
+    fileTypes,
+    pageToken: null,
+    tank: []
+  }
+
+  if (token) {
+    const saved = JSON.parse(Buffer.from(token, 'base64').toString())
+    state = { ...state, ...saved }
+    qob = state.qob
+    parentId = state.parentId
+    folderTypes = state.folderTypes
+    fileTypes = state.fileTypes
+  }
 
   // DriveApp doesnt give option to specify these so this will be fixed
   const fields = `files(${minFields}),nextPageToken`
@@ -49,9 +68,9 @@ export const getFilesIterator = ({
    */
   function* filesink() {
     // the result tank
-    let tank = []
+    let tank = [...state.tank]
     // the next page token
-    let pageToken = null
+    let pageToken = state.pageToken
 
     do {
       // if nothing in the tank, fill it up
@@ -63,10 +82,14 @@ export const getFilesIterator = ({
         // format the results into the folder or file object
         assert.array(data.files)
         assert.function(DriveApp.__settleClass)
-        tank = data.files.map(DriveApp.__settleClass)
+        
+        // we store raw data in state for continuation
+        state.tank = data.files
+        tank = [...state.tank]
 
         // the presence of a nextPageToken is the signal that there's more to come
         pageToken = data.nextPageToken
+        state.pageToken = pageToken
 
         // if we still have nothing in the tank but there's a page token, keep going
         if (!tank.length && !pageToken) break;
@@ -74,7 +97,12 @@ export const getFilesIterator = ({
 
       // if we've got anything in the tank send back the oldest one
       if (tank.length) {
-        yield tank.splice(0, 1)[0]
+        const raw = tank.splice(0, 1)[0]
+        state.tank.splice(0, 1)
+        yield { 
+          __fakeResolved: DriveApp.__settleClass(raw),
+          __fakeRaw: raw
+        }
       }
 
       // if there's still anything left in the tank, 
@@ -85,9 +113,26 @@ export const getFilesIterator = ({
   // create the iterator
   const fileit = filesink()
 
+  const continuationHandler = (peeked) => {
+    // if we've peeked, we need to make sure the peeked item is included in the tank
+    // because GAS continuation tokens should represent the state AFTER the last next() call.
+    // Peeker already called generator.next(), so the item to be returned by the NEXT next() call
+    // is in peeked.value.
+    const tank = [...state.tank]
+    if (peeked && !peeked.done) {
+      // Put the pre-fetched item back at the start of the tank for the token
+      tank.unshift(peeked.value.__fakeRaw || peeked.value)
+    }
+    const tokenState = {
+      ...state,
+      tank
+    }
+    return Buffer.from(JSON.stringify(tokenState)).toString('base64')
+  }
+
   // a regular iterator doesnt support the same methods 
   // as Apps Script so we'll fake that too
-  return newPeeker(fileit)
+  return newPeeker(fileit, continuationHandler)
 
 }
 

package/src/services/driveapp/fakedriveapp.js

@@ -5,6 +5,8 @@ import { notYetImplemented, isFolder } from '../../support/helpers.js'
 import { Proxies } from '../../support/proxies.js'
 import { Utils } from '../../support/utils.js'
 import { Access, Permission } from '../enums/driveenums.js'
+import { getFilesIterator } from './driveiterators.js'
+import { Syncit } from '../../support/syncit.js'
 const { is } = Utils
 
 
@@ -19,6 +21,7 @@ export class FakeDriveApp {
     this.__rootFolder = null
     this.folderApp = newFakeFolderApp()
     this.__settleClass = (file) => isFolder(file) ? newFakeDriveFolder(file) : newFakeDriveFile(file)
+    this.__enforceSingleParent = true
   }
 
 
@@ -133,37 +136,68 @@ export class FakeDriveApp {
     return this.getRootFolder().createFolder(name)
   }
 
-  //-- TODO ---
+  createShortcut(targetId, resourceKey) {
+    return this.getRootFolder().createShortcut(targetId, resourceKey)
+  }
 
-  getFolderByIdAndResourceKey() {
-    return notYetImplemented('getFolderByIdAndResourceKey')
+  createShortcutForTargetIdAndResourceKey(targetId, resourceKey) {
+    return this.getRootFolder().createShortcutForTargetIdAndResourceKey(targetId, resourceKey)
   }
-  getFileByIdAndResourceKey() {
-    return notYetImplemented('getFileByIdAndResourceKey')
+
+  getFolderByIdAndResourceKey(id, resourceKey) {
+    return this.getFolderById(id)
   }
 
-  continueFileIterator() {
-    return notYetImplemented('continueFileIterator')
+  getFileByIdAndResourceKey(id, resourceKey) {
+    return this.getFileById(id)
   }
-  continueFolderIterator() {
-    return notYetImplemented('continueFolderIterator')
+
+  continueFileIterator(token) {
+    return getFilesIterator({ token })
+  }
+
+  continueFolderIterator(token) {
+    return getFilesIterator({ token })
   }
+
   getTrashedFiles() {
-    return notYetImplemented('getTrashedFiles')
+    return getFilesIterator({
+      folderTypes: false,
+      fileTypes: true,
+      qob: ['trashed = true']
+    })
   }
+
   getTrashedFolders() {
-    return notYetImplemented('getTrashedFolders')
+    return getFilesIterator({
+      folderTypes: true,
+      fileTypes: false,
+      qob: ['trashed = true']
+    })
   }
 
   getStorageLimit() {
-    return notYetImplemented('getStorageLimit')
+    const { data } = Syncit.fxDrive({
+      prop: 'about',
+      method: 'get',
+      params: { fields: 'storageQuota' }
+    })
+    return parseInt(data.storageQuota.limit, 10)
   }
+
   getStorageUsed() {
-    return notYetImplemented('getStorageUsed')
+    const { data } = Syncit.fxDrive({
+      prop: 'about',
+      method: 'get',
+      params: { fields: 'storageQuota' }
+    })
+    return parseInt(data.storageQuota.usage, 10)
   }
-  enforceSingleParent() {
-    return notYetImplemented('enforceSingleParent')
+
+  enforceSingleParent(enabled) {
+    this.__enforceSingleParent = enabled
   }
+
   get Access() {
     return Access
   }